home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / phigs / ptk.lha / ptk / source / library / topo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-01  |  69.9 KB  |  2,541 lines
  1. /*----------------------------------------------------------------------------
  2.  
  3.  Module name: TopDraw
  4.  
  5.  Author: Toby Howard
  6.  
  7.  Function: Implements the PHIGS structure network topology drawing tool.
  8.  
  9.  External function list: ptk_topology.
  10.  
  11.  Internal function list:
  12.  
  13.  Hashtables used: "structureid", "name", "label".
  14.  
  15.  Modification history: (Version), (Date), (Name), (Description).
  16.  
  17.  1.0, ????, Toby Howard, First version.
  18.  
  19.  1.1, 29th July 1988, Steve Larkin, Modified to use Vax Phigs instead of 
  20.  KRT3.
  21.  
  22.  2.0, 10th June 1991, Gareth Williams, Translated to C.
  23.  
  24.  3.0, June 1992, Gareth Williams, Converted to ISO PHIGS C.
  25.  
  26. ----------------------------------------------------------------------------*/
  27.  
  28. #include <stdio.h>
  29. #include <math.h>
  30. #include <phigs.h>
  31. #include "ptk.h"
  32.  
  33. /*--------------------------------------------------------------------------*/
  34.  
  35. /* The width and height of the nodes in the diagram */
  36.  
  37. #define WIDTH              1.0
  38.  
  39. #define HEIGHT             1.0
  40.  
  41. /* The horizontal and vertical separations of the nodes */
  42.  
  43. #define HSPACING        (3.0 * WIDTH)
  44.  
  45. #define VSPACING        (4.0 * HEIGHT)
  46.  
  47. /* for storage of structure information */
  48.  
  49. typedef struct ptksstruct 
  50. {
  51.   Pint name;          /* structure identifier */
  52.   Pint numchildren;   /* number of children */
  53.   Pint numunique;     /* number of unique children */
  54.   Pint level;         /* max level in picture */
  55.   Ppoint pos;        /* position in picture */
  56.   ptkboolean placed;     /* placed yet? */
  57.   struct ptksref *firstchild, *lastchild;    /* list of children */
  58.   struct ptksref *firstparent, *lastparent;  /* list of parents */
  59.   struct ptksstruct *next;                   /* next ptksstruct record */
  60. } ptksstruct;
  61.  
  62. /*  for storage of structure references  */
  63.  
  64. typedef struct ptksref 
  65. {
  66.   ptksstruct *structptr;  /* structure being referenced */
  67.   Pint element;          /* element doing the referencing */
  68.   struct ptksref *next;      /* next ptksreference */
  69. } ptksref;
  70.  
  71. /* this is a node in the diagram */
  72.  
  73. typedef struct ptksnode 
  74. {
  75.   ptksstruct *structptr;
  76.   struct ptksnode *next;
  77. } ptksnode;
  78.  
  79. /* this is for the list of rows */
  80.  
  81. typedef struct ptksrow 
  82. {
  83.   Pint num;
  84.   ptksnode *n;
  85.   struct ptksrow *next;
  86. } ptksrow;
  87.  
  88. typedef struct ptkskeytable 
  89. {
  90.   char key[256], an[256];
  91. } ptkskeytable;
  92.  
  93. typedef struct ptkstopdraw 
  94. {
  95.   Pint topologyid;
  96.   Pint topologystid;
  97.   ptketopologytype topologytype;
  98.   Pint txfont;
  99.   Pint textcolour;
  100.   Pint linecolour;
  101.   Pint edgecolour;
  102.   Pint intcolour;
  103.   Pint topologyname;
  104.   Pint_list posted;
  105.   
  106.   /* highlight node */
  107.   Pint highlightnode;
  108.   Pint highlightedge;
  109.   Pint highlightint;
  110.  
  111.   struct ptkstopdraw *next;
  112.   
  113.   Pint root;
  114.  
  115.   Pint_list hlist;               /* list of nodes to highlight ? */
  116.   ptksstruct *structlist;      /* the head of the structure info list */
  117.   ptksrow *rowlist;            /* the head of the row list */
  118.  
  119.   Pmatrix3 globaltran, mat;
  120.   Pelem_ref_list_list *pathlist;     /* structure network paths */
  121.   Pstore pathdata;               /* buffer to hold paths data */
  122.  
  123.   Pfloat annotextheight;     /* size of characters for annotation */
  124.   Pint nodebounds;           /* for drawing the nodes */
  125.   Ppoint nodepoints[5];
  126.   Pfloat nodeheight, nodewidth;
  127.  
  128.   Plimit3 extent;
  129.   Pfloat xinc, yinc;
  130.   Pfloat rowmaxx[255];
  131.   Pfloat topx, topy;
  132.   Pint maxlevel;
  133.   
  134.   ptkskeytable keytablelst[255];
  135.   Pint keyno;
  136. } ptkstopdraw;
  137.  
  138. /*--------------------------------------------------------------------------*/
  139.  
  140. static ptkstopdraw *topptr = NULL;
  141.  
  142. static ptkstopdraw *firsttop = NULL;
  143. static ptkstopdraw *lasttop = NULL;
  144. static nodeidcount = 0;
  145.  
  146. static topologycount = 0;
  147.  
  148. /*--------------------------------------------------------------------------*/
  149.  
  150. static void settop(C(Pint) topid)
  151. PreANSI(Pint topid)
  152. {
  153.   ptkstopdraw *ptr;
  154.  
  155.   if (firsttop == NULL)
  156.   {
  157.     topptr = NULL;
  158.     return;
  159.   }
  160.   ptr = firsttop;
  161.   while (ptr->topologyid != topid)
  162.   {
  163.     ptr = ptr->next;
  164.     if (ptr == NULL)
  165.     {
  166.       topptr = NULL;
  167.       return;
  168.     }
  169.   }
  170.   topptr = ptr;
  171. }  /* settop */
  172.  
  173. /*--------------------------------------------------------------------------*/
  174.  
  175. static void note(C(Pfloat) xx, C(Pfloat) yy)
  176. PreANSI(Pfloat xx)
  177. PreANSI(Pfloat yy)
  178. /*
  179. ** \parambegin
  180. ** \param{}{xx}{x coordinate}{IN}
  181. ** \param{}{yy}{y coordinate}{IN}
  182. ** \paramend
  183. ** \blurb{Updates `extent' using xx, yy.}
  184. */
  185. {
  186.   if (xx > topptr->extent.x_max)
  187.     topptr->extent.x_max = xx;
  188.   if (yy > topptr->extent.y_max)
  189.     topptr->extent.y_max = yy;
  190.   if (xx < topptr->extent.x_min)
  191.     topptr->extent.x_min = xx;
  192.   if (yy < topptr->extent.y_min)
  193.     topptr->extent.y_min = yy;
  194. }  /* note */
  195.  
  196. /*--------------------------------------------------------------------------*/
  197.  
  198. /* Key handling
  199. **
  200. ** When the algorithm has drawn the nodes for all the structures in
  201. ** the hierarchy, it attempts to draw the structure names against the nodes,
  202. ** and tries various positions to avoid overlapping with adjacent nodes. If
  203. ** it is unable to place the text reasonably, it gives up, and resorts to
  204. ** a simple 'key' scheme, where the name is associated with a key, and the
  205. ** node is labelled with the key instead of the full name (the assumption
  206. ** being that the key will be only a few characters long. If keys are used, a
  207. ** list of keys and their corresponding names is added to the picture at the
  208. ** end.
  209. */
  210.  
  211. /*--------------------------------------------------------------------------*/
  212.  
  213. static void setkey(C(char *) v, C(char *) k)
  214. PreANSI(char *v)
  215. PreANSI(char *k)
  216. /*
  217. ** \parambegin
  218. ** \param{}{v}{string to allocate a key for}{IN}
  219. ** \param{}{k}{key allocated to string ( a, b etc.)}{IN}
  220. ** \paramend
  221. ** \blurb{Allocates a key to string 'v', and records the correspondence
  222. ** in the key table.}
  223. */
  224. {
  225.   ptkskeytable *keyptr;
  226.  
  227.   topptr->keyno++;
  228.   keyptr = &topptr->keytablelst[topptr->keyno - 1];
  229.   keyptr->key[1] = '\0';
  230.   keyptr->key[0] = (char)(topptr->keyno + 96);
  231.  
  232.   /* keys are labelled from 'a' upwards */
  233.   strcpy(k, keyptr->key);   /* return the key allocated */
  234.   strcpy(keyptr->an, v);
  235. }  /* setkey */
  236.  
  237. /*--------------------------------------------------------------------------*/
  238.  
  239. static void drawkeys(C(void))
  240. /*
  241. ** \blurb{Start the list of keys at xmin, and drop a node's
  242. ** worth below the minimum y.}
  243. */
  244. {
  245.   Pint i;
  246.   Ppoint tp;
  247.   ptkskeytable *keyptr;
  248.   char str[256];
  249.  
  250.   if (topptr->keyno > 0)
  251.   {
  252.     tp = ptk_point(topptr->extent.x_min,
  253.                   topptr->extent.y_min - topptr->nodeheight);
  254.     for (i = 0; i < topptr->keyno; i++) 
  255.     {
  256.       keyptr = &topptr->keytablelst[i];
  257.       sprintf(str, "%s    %s", keyptr->key, keyptr->an);
  258.       tp.y -= topptr->annotextheight * 1.5;
  259.       ptext(&tp, str);
  260.     }
  261.     /* Record the limits of the keytable */
  262.     note(tp.x, tp.y); 
  263.   }
  264. }  /* drawkeys */
  265.  
  266. /*--------------------------------------------------------------------------*/
  267.  
  268. static void setscaling(C(void))
  269. /*
  270. ** \blurb{Computes the transformation to scale the picture
  271. ** into [0,1], and inserts a setglobaltran at the start of the picture.}
  272. */
  273. {
  274.   Ppoint3 sc, sh;
  275.   Pint err, el;
  276.   Pfloat height, width, scale;
  277.   Ppoint3 topshift, topscale;
  278.  
  279.   topptr->extent.x_min -= topptr->nodewidth;
  280.   topptr->extent.x_max += topptr->nodewidth;
  281.   topptr->extent.y_min -= topptr->nodeheight;
  282.   topptr->extent.y_max += topptr->nodeheight;
  283.   height = topptr->extent.y_max - topptr->extent.y_min;
  284.   width = topptr->extent.x_max - topptr->extent.x_min;
  285.   scale = 1.0/PTKMAX(height, width);
  286.   topshift = ptk_point3(-topptr->extent.x_min - (width / 2.0),
  287.                         -topptr->extent.y_min - (height / 2.0), 0.0), 
  288.   ptk_shift3(&topshift, PTYPE_REPLACE, topptr->globaltran); 
  289.   topscale = ptk_point3(scale, scale, scale);
  290.   ptk_scale3(&topscale, PTYPE_POSTCONCAT, topptr->globaltran);
  291.   topshift = ptk_point3(0.5, 0.5, 0.0);
  292.   ptk_shift3(&topshift, PTYPE_POSTCONCAT, topptr->globaltran); 
  293.   /* Squeeze in a global transformation at the
  294.      top of the structure */
  295.   pset_elem_ptr(0);
  296.   pset_elem_ptr_label(ptk_stringtoint("label", "globaltran"));
  297.   pset_global_tran3(topptr->globaltran);
  298. }  /* setscaling */
  299.  
  300. /*--------------------------------------------------------------------------*/
  301.  
  302. static ptkboolean overlap(C(Ppoint *) p, C(Pfloat) stringw, C(Pfloat) stringh)
  303. PreANSI(Ppoint *p)
  304. PreANSI(Pfloat stringw)
  305. PreANSI(Pfloat stringh)
  306. /*
  307. ** \parambegin
  308. ** \param{}{p}{point to check for overlapping nodes}{IN}
  309. ** \param{}{stringw}{character string width}{IN}
  310. ** \param{}{stringh}{character string height}{IN}
  311. ** \paramend
  312. ** \blurb{Given a point p, checks against all the positioned nodes 
  313. ** to see if any lie between p and and another point q, 'stringw' 
  314. ** horizontally away from p.
  315. ** Returns TRUE if there is an overlapping node, otherwise FALSE.}
  316. */
  317. {
  318.   ptksstruct *sp;
  319.   ptkboolean over;
  320.  
  321.   over = FALSE;
  322.   sp = topptr->structlist;
  323.   while (sp != NULL && !over) 
  324.   {   
  325.     /* look at each node */
  326.     if ((p->y <= sp->pos.y + topptr->nodeheight / 2.0) &&
  327.     (p->y + stringh >= sp->pos.y - topptr->nodeheight / 2.0)) 
  328.     {
  329.       /* it overlaps the node vertically, so now test if the
  330.          node lies somewhere inside the extent */
  331.       if ((p->x < sp->pos.x + topptr->nodewidth / 2.0) &&
  332.       (p->x + stringw > sp->pos.x - topptr->nodewidth / 2.0))
  333.     over = TRUE;
  334.     }
  335.     sp = sp->next;
  336.   }
  337.   return over;
  338. }  /* overlap */
  339.  
  340. /*--------------------------------------------------------------------------*/
  341.  
  342. static void setnode(C(Pfloat) w, C(Pfloat) h)
  343. PreANSI(Pfloat w)
  344. PreANSI(Pfloat h)
  345. /*
  346. ** \parambegin
  347. ** \param{}{w}{node width}{IN}
  348. ** \param{}{h}{node height}{IN}
  349. ** \paramend
  350. ** \blurb{Establishes the size of a node, centred.}
  351. */
  352. {
  353.   topptr->nodebounds = 5;
  354.   topptr->nodepoints[0] = ptk_point(w/-2.0, h/-2.0);
  355.   topptr->nodepoints[1] = ptk_point(w/2.0, h/-2.0);
  356.   topptr->nodepoints[2] = ptk_point(w/2.0, h/2.0);
  357.   topptr->nodepoints[3] = ptk_point(w/-2.0, h/2.0);
  358.   topptr->nodepoints[4] = ptk_point(w/-2.0, h/-2.0);
  359.   pset_char_ht(h/2.0);
  360.   topptr->annotextheight = h / 2.0;
  361. }  /* setnode */
  362.  
  363. /*--------------------------------------------------------------------------*/
  364.  
  365. static void initialise(C(void))
  366. /*
  367. ** \blurb{Initialise topdraw values.}
  368. */
  369. {
  370.   Pint k;
  371.  
  372.   topptr->structlist = NULL;   /* no structures to start with */
  373.   topptr->rowlist = NULL;   /* and no rows */
  374.   topptr->keyno = 0;   /* no debugging printing, no keys */
  375.   for (k = 0; k <= 254; k++)
  376.     topptr->rowmaxx[k] = -32768.0;
  377.   topptr->maxlevel = 1;
  378. }  /* initialise */
  379.  
  380. /*--------------------------------------------------------------------------*/
  381.  
  382. static ptkboolean lookupstructure(C(Pint) sn, C(ptkboolean) create, 
  383.                                C(ptksstruct **) sp)
  384. PreANSI(Pint sn)
  385. PreANSI(ptkboolean create)
  386. PreANSI(ptksstruct **sp)
  387. /*
  388. ** \parambegin
  389. ** \param{}{sn}{structure identifier to look up}{IN}
  390. ** \param{}{create}{add to structlist if TRUE, do nothing if FALSE}{IN}
  391. ** \param{}{sp}{pointer to structure record}{IN}
  392. ** \paramend
  393. ** \blurb{Looks for a structure in the namelist, and inserts it
  394. ** if it's not there, and create=TRUE. Returns a pointer to the name
  395. ** record, or NIL if it wasn't found and not created. The result is 
  396. ** TRUE if it was created.
  397. ** Returns TRUE if new record created, otherwise FALSE.}
  398. */
  399. {
  400.   ptkboolean found;
  401.   ptksstruct *last, *s, *news;
  402.  
  403.   s = topptr->structlist;
  404.   found = FALSE;
  405.   *sp = NULL;
  406.   while (!found && s != NULL) 
  407.   {
  408.     found = (sn == s->name);
  409.     if (found)
  410.       break;
  411.     last = s;
  412.     s = s->next;
  413.   }
  414.   if (found) 
  415.   {
  416.     *sp = s;
  417.     return (!found && create);
  418.   }
  419.   if (!create) 
  420.   {
  421.     return (!found && create);
  422.   }  /* not found and created */
  423.   news = (ptksstruct *)malloc(sizeof(ptksstruct));
  424.   *sp = news;
  425.   if (topptr->structlist == NULL)   /* initialise the record */
  426.     topptr->structlist = news;
  427.   else
  428.     last->next = news;
  429.   news->name = sn;
  430.   news->level = 0;
  431.   news->next = NULL;
  432.   news->numchildren = ptk_countchildren(sn);
  433.   news->numunique = ptk_countuniqchildren(sn);
  434.   news->firstchild = NULL;
  435.   news->lastchild = NULL;
  436.   news->firstparent = NULL;
  437.   news->lastparent = NULL;
  438.   news->placed = FALSE;
  439.   news->pos = ptk_point(0.0, 0.0);
  440.   return (!found && create);
  441. }  /* lookupstructure */
  442.  
  443. /*--------------------------------------------------------------------------*/
  444.  
  445. static void drawnames(C(void))
  446. /*
  447. ** \blurb{Draws the name of the structure next to its node.
  448. ** First we'll try and draw the string to the right of the node, which
  449. ** seems like a good place. If that would splash over another node
  450. ** nearby,we'll try the left instead. If both are no good, give up,and
  451. ** use a key instead.}
  452. */
  453. {
  454.   Ppoint tp;
  455.   ptksstruct *sp;
  456.   Pmatrix3 mat;
  457.   Pint textrep;
  458.   char k[256], annot[256];
  459.   Ptext_align a;
  460.   Pint lenstr;
  461.   ptkboolean donames;
  462.  
  463.   ptk_unitmatrix3(mat);
  464.   pset_local_tran3(mat, PTYPE_REPLACE);
  465.   a.hor = PHOR_NORM;
  466.   a.vert = PVERT_HALF;
  467.   pset_text_align(&a);
  468.   donames = ptk_hashtableused("structureid");
  469.   sp = topptr->structlist;   /* going to scan the structure list */
  470.   while (sp != NULL) 
  471.   {
  472.     /* place text to the right of the node */
  473.     tp = ptk_point(sp->pos.x + 3.0 * WIDTH / 4.0, sp->pos.y);
  474.     if (donames)
  475.     {
  476.       ptk_inttostring("structureid", sp->name, 256, annot, &lenstr);
  477.       if (lenstr == 0)
  478.         sprintf(annot, "%d\0", sp->name); 
  479.     }
  480.     else
  481.       sprintf(annot, "%d\0", sp->name); 
  482.     /* should use inqtextextent to get width of string */
  483.     if (overlap(&tp, (Pfloat)strlen(annot) * topptr->annotextheight,
  484.         topptr->annotextheight)) 
  485.     {
  486.       /* no good. now try to place it to the left of the node */
  487.       tp.x = sp->pos.x - topptr->nodewidth / 2.0 -
  488.          (Pfloat)strlen(annot) * topptr->annotextheight;
  489.       if (overlap(&tp, strlen(annot) * topptr->annotextheight,
  490.           topptr->annotextheight)) 
  491.       {
  492.     /* Need to resort to a key here. Reset the text position
  493.        to inside the node, and get a key */
  494.         tp = ptk_point(sp->pos.x + 3.0 * WIDTH / 4.0, sp->pos.y);
  495.     setkey(annot, k);
  496.         note(tp.x + topptr->annotextheight, tp.y);
  497.     ptext(&tp, k);
  498.       } 
  499.       else 
  500.       {  
  501.         /* place text to the left */
  502.     note(tp.x, tp.y);
  503.     tp.x = sp->pos.x - topptr->nodeheight * 3.0 / 4.0;
  504.     a.hor = PHOR_RIGHT;
  505.     a.vert = PVERT_HALF;
  506.     pset_text_align(&a);
  507.     ptext(&tp, annot);
  508.     a.hor = PHOR_NORM;
  509.     a.vert = PVERT_HALF;
  510.     pset_text_align(&a);
  511.       }
  512.     } 
  513.     else 
  514.     {  
  515.       /* no overlap */
  516.       note(tp.x + (Pfloat)strlen(annot) * topptr->annotextheight, tp.y);
  517.       ptext(&tp, annot);
  518.     }
  519.     sp = sp->next;
  520.   }
  521. }  /* drawnames */
  522.  
  523. /*--------------------------------------------------------------------------*/
  524.  
  525. static Pint findlowestchild(C(ptksstruct *) root)
  526. PreANSI(ptksstruct *root)
  527. /*
  528. ** \parambegin
  529. ** \param{}{root}{pointer to root structure record}{IN}
  530. ** \paramend
  531. ** \blurb{Looks at all the immediate children of 'root', and
  532. ** returns the level of the deepest one.
  533. ** Returns level of lowest child of root.}
  534. */
  535. {
  536.   ptksref *r;
  537.   Pint l;
  538.  
  539.   l = 0;
  540.   r = root->firstchild;
  541.   while (r != NULL) 
  542.   {
  543.     if (r->structptr->level > l)
  544.       l = r->structptr->level;
  545.     r = r->next;
  546.   }
  547.   return l;
  548. }  /* findlowestchild */
  549.  
  550. /*--------------------------------------------------------------------------*/
  551.  
  552. static void placetree(C(ptksstruct *) root, C(Pfloat *) x, C(Pfloat) y)
  553. PreANSI(ptksstruct *root)
  554. PreANSI(Pfloat *x)
  555. PreANSI(Pfloat y)
  556. /*
  557. ** \parambegin
  558. ** \param{}{root}{pointer to root structure record.}{IN}
  559. ** \param{}{x}{x coordinate of node}{IN}
  560. ** \param{}{y}{y coordinate of node}{IN}
  561. ** \paramend
  562. ** \blurb{Places a subtree.}
  563. */
  564. {
  565.   Pint n, fudge;
  566.   ptksref *r;
  567.   Pfloat fuzz, finetune, xx, xxinc;
  568.  
  569.   if (root->placed)
  570.     return;
  571.  
  572.   n = root->numunique;
  573.  
  574.   fudge = findlowestchild(root) - root->level;
  575.  
  576.   finetune = 1.0;
  577.   xxinc = topptr->xinc * fudge * finetune;
  578.  
  579.   xx = *x - ((Pfloat)n - 1.0) * xxinc / 2.0;
  580.   fuzz = topptr->nodewidth * 1.5;
  581.  
  582.   if (n > 1) 
  583.   {   
  584.     /* at least one child */
  585.     if (xx <= topptr->rowmaxx[root->level] + fuzz) 
  586.     {
  587. /*      printf("adjusting for overlap at level %ld\n", root->level + 1); */
  588.       /* compute x pos of leftmost child */
  589.       xx = topptr->rowmaxx[root->level] + xxinc;
  590.       /* now readjust x to center node over its children */
  591.       *x = xx + ((Pfloat)n - 1.0) * xxinc / 2.0;
  592.     }
  593.   }
  594.  
  595.   y = 0.0 - root->level * topptr->yinc;
  596.  
  597.   root->pos = ptk_point(*x, y);
  598.  
  599.   topptr->rowmaxx[root->level - 1] = *x;
  600.  
  601.   root->placed = TRUE;
  602.  
  603.   r = root->firstchild;
  604.   while (r != NULL) 
  605.   {
  606.     placetree(r->structptr, &xx, y);
  607.     r = r->next;
  608.     xx += xxinc;
  609.   }
  610. }  /* placetree */
  611.  
  612. /*--------------------------------------------------------------------------*/
  613.  
  614. static void placenodes(C(void))
  615. /*
  616. ** \blurb{Draws all the nodes for the structures in the hierarchy.}
  617. */
  618. {
  619.   topptr->topx = 0.0;
  620.   topptr->topy = 0.0;
  621.   topptr->nodeheight = 1.0;
  622.   topptr->nodewidth = 1.0;
  623.   setnode(1.0, 1.0);
  624.   topptr->xinc = topptr->nodewidth * 2.0;
  625.   topptr->yinc = topptr->nodeheight * 2.0;
  626.       
  627.   /* start it off with a silly value */
  628.  
  629.   topptr->extent = ptk_limit3(1000000.0, -10000000.0, 10000000.0,
  630.                                -10000000.0, 0.0, 1.0);
  631.  
  632.   /* Recursively place all the nodes, starting at 0,0. The diagram
  633.   ** will grow downwards, and its ultimate extent will be in `extent'.
  634.   ** Everytime a new bit is drawn, its position is noted with `note',
  635.   ** which updates the extent. 
  636.   */
  637.  
  638.   placetree(topptr->structlist, &topptr->topx, topptr->topy);
  639. }  /* placenodes */
  640.  
  641. /*--------------------------------------------------------------------------*/
  642.  
  643. static void drawnode(C(ptksstruct *) sp)
  644. PreANSI(ptksstruct *sp)
  645. /*
  646. ** \parambegin
  647. ** \param{}{sp}{pointer to structure record}{IN}
  648. ** \paramend
  649. ** \blurb{Draws a node to represent the structure at sp in the
  650. ** structure list, and the node will go into the diagram at xx, yy.}
  651. */
  652. {
  653.   Ppoint3 sh;
  654.   Ppoint_list sets;
  655.   Pint err, elptr;
  656.  
  657.   sh = ptk_point3(sp->pos.x, sp->pos.y, 0.0);
  658.   ptk_shift3(&sh, PTYPE_REPLACE, topptr->mat);
  659.   sets.num_points = topptr->nodebounds;
  660.   sets.points = topptr->nodepoints;
  661.   if (nodeidcount == topptr->highlightnode)
  662.   {
  663.     /* jump to `highlightnode' label */
  664.     pinq_elem_ptr(&err, &elptr);
  665.     pset_elem_ptr(0);
  666.     pset_elem_ptr_label(ptk_stringtoint("label", "highlightnode"));
  667.     pset_pick_id(sp->name);
  668.     pset_local_tran3(topptr->mat, PTYPE_REPLACE);
  669.     ptk_fillareaset(1, &sets);
  670.     /* jump back */
  671.     pset_elem_ptr(elptr + 3);
  672.   }
  673.   else
  674.   {
  675.     pset_pick_id(sp->name);
  676.     pset_local_tran3(topptr->mat, PTYPE_REPLACE);
  677.     ptk_fillareaset(1, &sets);
  678.   }
  679.   note(sp->pos.x, sp->pos.y);
  680. }  /* drawnode */
  681.  
  682. /*--------------------------------------------------------------------------*/
  683.  
  684. static void drawnodes(C(void))
  685. /*
  686. ** \blurb{Draw all nodes in structure network.}
  687. */
  688. {
  689.   ptksstruct *s;
  690.  
  691.   s = topptr->structlist;
  692.   nodeidcount = 0;
  693.   while (s != NULL) 
  694.   {
  695.     drawnode(s);
  696.     nodeidcount++;
  697.     s = s->next;
  698.   }
  699. }  /* drawnodes */
  700.  
  701. /*--------------------------------------------------------------------------*/
  702.  
  703. static void drawstructnetnode(C(ptksstruct *) sp)
  704. PreANSI(ptksstruct *sp)
  705. /*
  706. ** \parambegin
  707. ** \param{}{sp}{pointer to structure record}{IN}
  708. ** \paramend
  709. ** \blurb{Draws a node to represent the structure at sp in the
  710. ** structure list, and the node will go into the diagram at xx, yy.}
  711. */
  712. {
  713.   Plimit3 boundbox, nodebox;
  714.   Pmatrix3 matrix;
  715.   Pint err, elptr;
  716.   Ppoint3 sh;
  717.  
  718.   if (ptk_boundingbox(sp->name, &boundbox, TRUE))
  719.   {
  720.     nodebox = ptk_limit3(-0.5, 0.5, -0.5, 0.5, 0.0, 1.0); 
  721.     sh = ptk_point3(sp->pos.x, sp->pos.y, 0.0);
  722.     ptk_shift3(&sh, PTYPE_REPLACE, topptr->mat);
  723.     ptk_box3tobox3(&boundbox, &nodebox, TRUE, PTYPE_PRECONCAT, topptr->mat, 
  724.                    &err);
  725.     /* jump to `globaltran' label, this avoids attribute inheritance
  726.     ** from the topology structure.
  727.     */
  728.     pinq_elem_ptr(&err, &elptr);
  729.     pset_elem_ptr(0);
  730.     pset_elem_ptr_label(ptk_stringtoint("label", "globaltran"));
  731.     pset_pick_id(sp->name);
  732.     pset_local_tran3(topptr->mat, PTYPE_REPLACE);
  733.     pexec_struct(sp->name);
  734.     /* jump back */
  735.     pset_elem_ptr(elptr + 3);
  736.     note(sp->pos.x, sp->pos.y);
  737.   }
  738.   else
  739.     drawnode(sp);
  740. }  /* drawstructnetnode */
  741.  
  742. /*--------------------------------------------------------------------------*/
  743.  
  744. static delstructnodes()
  745. {
  746.   char sname[80];
  747.   ptksstruct *s;
  748.  
  749.   s = topptr->structlist;
  750.   while (s != NULL)
  751.   {
  752.     if (s->numchildren > 0)
  753.     {
  754.       sprintf(sname, "ptk$topologynode%d", s->name);
  755.       pdel_struct(ptk_stringtoint("structureid", sname));
  756.       ptk_delstring("structureid", sname);
  757.     }
  758.     s = s->next;
  759.   }
  760. } /* delstructnodes */
  761.  
  762. /*--------------------------------------------------------------------------*/
  763.  
  764. static void drawstructnode(C(ptksstruct *) sp)
  765. PreANSI(ptksstruct *sp)
  766. /*
  767. ** \parambegin
  768. ** \param{}{sp}{pointer to structure record}{IN}
  769. ** \paramend
  770. ** \blurb{Draws a node to represent the structure at sp in the
  771. ** structure list, and the node will go into the diagram at xx, yy.}
  772. */
  773. {
  774.   Plimit3 boundbox, nodebox;
  775.   Pmatrix3 matrix;
  776.   Pint err, numchild, elptr, stendptr[2], lstnum;
  777.   Ppoint3 sh;
  778.   char sname[255];
  779.   Pelem_type elemlist[1];
  780.   Psearch_status srchstat;
  781.   ptkboolean validbox;
  782.  
  783.   validbox = ptk_boundingbox(sp->name, &boundbox, FALSE);
  784.   if (validbox)
  785.   {
  786.     if (sp->numchildren > 0)
  787.     {
  788.       sprintf(sname, "ptk$topologynode%d", sp->name);
  789.       if (!ptk_structexists(ptk_stringtoint("structureid", sname)))
  790.       {
  791.         ptk_openstruct(ptk_stringtoint("structureid", sname));
  792.         pcopy_all_elems_struct(sp->name);
  793.         /* remove all execute structs */
  794.         elptr = 0;
  795.         elemlist[0] = PELEM_EXEC_STRUCT;
  796.         pset_elem_ptr(0);
  797.         do
  798.         {
  799.           ptk_findelemtype(elemlist, 1, PDIR_FORWARD, &srchstat, &elptr, &lstnum);
  800.           if (srchstat == PSEARCH_STATUS_SUCCESS)
  801.           {
  802.             pset_elem_ptr(elptr);
  803.             pdel_elem();
  804.           }
  805.         } while (srchstat == PSEARCH_STATUS_SUCCESS);
  806.         ptk_closestruct();
  807.       }
  808.       if (validbox)
  809.       {
  810.         sh = ptk_point3(sp->pos.x, sp->pos.y, 0.0);
  811.         ptk_shift3(&sh, PTYPE_REPLACE, topptr->mat);
  812.         nodebox = ptk_limit3(-0.5, 0.5, -0.5, 0.5, 0.0, 1.0); 
  813.         ptk_box3tobox3(&boundbox, &nodebox, TRUE, PTYPE_PRECONCAT, 
  814.                        topptr->mat, &err);
  815.         pinq_elem_ptr(&err, &elptr);
  816.         pset_elem_ptr(0);
  817.         pset_elem_ptr_label(ptk_stringtoint("label", "globaltran"));
  818.         pset_pick_id(sp->name);
  819.         pset_local_tran3(topptr->mat, PTYPE_REPLACE);
  820.         pexec_struct(ptk_stringtoint("structureid", sname));
  821.         pset_elem_ptr(elptr + 3);
  822.         note(sp->pos.x, sp->pos.y);
  823.       }
  824.     }
  825.     else
  826.     {
  827.       sh = ptk_point3(sp->pos.x, sp->pos.y, 0.0);
  828.       ptk_shift3(&sh, PTYPE_REPLACE, topptr->mat);
  829.       nodebox = ptk_limit3(-0.5, 0.5, -0.5, 0.5, 0.0, 1.0);
  830.       ptk_box3tobox3(&boundbox, &nodebox, TRUE, PTYPE_PRECONCAT, topptr->mat, 
  831.                      &err);
  832.       pinq_elem_ptr(&err, &elptr);
  833.       pset_elem_ptr(0);
  834.       pset_elem_ptr_label(ptk_stringtoint("label", "globaltran"));
  835.       pset_pick_id(sp->name);
  836.       pset_local_tran3(topptr->mat, PTYPE_REPLACE);
  837.       pexec_struct(sp->name);
  838.       pset_elem_ptr(elptr + 3);
  839.       note(sp->pos.x, sp->pos.y);
  840.     }
  841.   }
  842.   else
  843.     drawnode(sp);
  844. }  /* drawstructnode */
  845.  
  846. /*--------------------------------------------------------------------------*/
  847.  
  848. static void drawstructnetnodes(C(void))
  849. /*
  850. ** \blurb{Draw all nodes in structure network.}
  851. */
  852. {
  853.   ptksstruct *s;
  854.  
  855.   s = topptr->structlist;
  856.   while (s != NULL) 
  857.   {
  858.     drawstructnetnode(s);
  859.     s = s->next;
  860.   }
  861. }  /* drawstructnetnodes */
  862.  
  863. /*--------------------------------------------------------------------------*/
  864.  
  865. static void drawstructnodes(C(void))
  866. /*
  867. ** \blurb{Draw all nodes in structure network.}
  868. */
  869. {
  870.   ptksstruct *s;
  871.  
  872.   s = topptr->structlist;
  873.   while (s != NULL) 
  874.   {
  875.     drawstructnode(s);
  876.     s = s->next;
  877.   }
  878. }  /* drawstructnodes */
  879.  
  880. /*--------------------------------------------------------------------------*/
  881.  
  882. static void drawarc(C(Pint) n, C(ptksstruct *) pp, C(ptksstruct *) pc)
  883. PreANSI(Pint n)
  884. PreANSI(ptksstruct *pp)
  885. PreANSI(ptksstruct *pc)
  886. /*
  887. ** \parambegin
  888. ** \param{}{n}{number of reference to p}{IN}
  889. ** \param{}{pp}{pointer to parent record}{IN}
  890. ** \param{}{pc}{pointer to child record}{IN}
  891. ** \paramend
  892. ** \blurb{Draws the connecting arc to show a reference to 'child'
  893. ** by 'parent'. It is 'parent's nth reference.}
  894. */
  895. {
  896.   Ppoint p[2];
  897.   Ppoint_list pts;
  898.  
  899.   p[0] = ptk_point(pp->pos.x - topptr->nodewidth / 2 +
  900.      n * topptr->nodewidth / (pp->numchildren + 1),
  901.          pp->pos.y - topptr->nodeheight / 2);
  902.   p[1] = ptk_point(pc->pos.x, pc->pos.y + topptr->nodeheight / 2);
  903.   pts.num_points = 2;
  904.   pts.points = p;
  905.   ppolyline(&pts);
  906. }  /* drawarc */
  907.  
  908. /*--------------------------------------------------------------------------*/
  909.  
  910. static void drawconnections(C(void))
  911. /*
  912. ** \blurb{This is called when all the structures' nodes have been 
  913. ** placed, and draws the arcs between the nodes which represent structure
  914. ** references.}
  915. */
  916. {
  917.   ptksstruct *s;
  918.   ptksref *child;
  919.   Pint childno;
  920.  
  921.   /* Wipe out the effects of any local trans for the nodes */
  922.   ptk_unitmatrix3(topptr->mat);
  923.   pset_local_tran3(topptr->mat, PTYPE_REPLACE);
  924.   s = topptr->structlist;
  925.   while (s != NULL) 
  926.   {   
  927.     /* process each structure in turn */
  928.     child = s->firstchild;
  929.     childno = 0;
  930.     while (child != NULL) 
  931.     {   
  932.       /* process each child in order */
  933.       childno++;
  934.       drawarc(childno, s, child->structptr);
  935.       child = child->next;
  936.     }
  937.     s = s->next;
  938.   }
  939. }  /* drawconnections */
  940.  
  941. /*--------------------------------------------------------------------------*/
  942.  
  943. static void addreference(C(ptksstruct *) pp, C(ptksstruct *) cp, C(Pint) e)
  944. PreANSI(ptksstruct *pp)
  945. PreANSI(ptksstruct *cp)
  946. PreANSI(Pint e)
  947. /*
  948. ** \parambegin
  949. ** \param{}{pp}{pointer to parent record}{IN}
  950. ** \param{}{cp}{pointer to child record}{IN}
  951. ** \param{}{e}{element pointer}{IN}
  952. ** \paramend
  953. ** \blurb{Stores a reference to 'child' at element e in 'parent'.}
  954. */
  955. {
  956.   ptksref *newref;
  957.  
  958.   newref = (ptksref *)malloc(sizeof(ptksref));
  959.   /* create a new reference node */
  960.   if (pp->firstchild == NULL)
  961.     pp->firstchild = newref;
  962.   else
  963.     pp->lastchild->next = newref;
  964.   pp->lastchild = newref;
  965.   newref->structptr = cp;
  966.   newref->element = e;
  967.   newref->next = NULL;
  968. }  /* addreference */
  969.  
  970. /*--------------------------------------------------------------------------*/
  971.  
  972. static void storereferences(C(void))
  973. /*
  974. ** \blurb{Runs along the structlist, inquiring the children of
  975. ** each structure, and storing the reference information.}
  976. */
  977. {
  978.   ptksstruct *s, *cp;
  979.   Pint e, err, foundel, tempstruct, errnum, numelts;
  980.   Psearch_status status;
  981.   ptkselcontent elcont;
  982.   Pint lstnum;
  983.   Pstore store;
  984.   Pelem_type exectype;
  985.   Pelem_type_list includelst, excludelst;
  986.  
  987.   s = topptr->structlist;
  988.   includelst.num_elem_types = 1;
  989.   exectype = PELEM_EXEC_STRUCT;
  990.   includelst.elem_types = &exectype;
  991.   excludelst.num_elem_types = 0;
  992.   excludelst.elem_types = NULL;
  993.   while (s != NULL) 
  994.   {
  995.     e = 0;
  996.     numelts = ptk_elemcount(s->name);
  997.     do
  998.     {
  999.       pelem_search(s->name, e, PDIR_FORWARD, &includelst, &excludelst, &err, 
  1000.                 &status, &foundel);
  1001.       e = foundel + 1;
  1002.       if (status == PSEARCH_STATUS_SUCCESS) 
  1003.       {
  1004.         pcreate_store(&err, &store);
  1005.     ptk_inqelemtypesizecontent(s->name, foundel, store, &errnum,
  1006.                                    &elcont);
  1007.         tempstruct = elcont.eldata->int_data;
  1008.         ptk_delstore(store);
  1009.         lookupstructure(tempstruct, FALSE, &cp);
  1010.         addreference(s, cp, foundel);
  1011.       }
  1012.     } while ((status != PSEARCH_STATUS_FAILURE) && (e <= numelts));
  1013.     s = s->next;   /* next structure */
  1014.   }
  1015. }  /* storereferences */
  1016.  
  1017. /*--------------------------------------------------------------------------*/
  1018.  
  1019. static ptksrow *selectrow(C(Pint) l, C(ptksrow **) last)
  1020. PreANSI(Pint l)
  1021. PreANSI(ptksrow **last)
  1022. /*
  1023. ** \blurb{Tries to return the address of the start of the `l'th row.
  1024. ** If this row doesn't exist yet, rowptr is NIL, and a pointer
  1025. ** to the previous row, if any, is returned in 'last'.}
  1026. */
  1027. {
  1028.   ptksrow *r;
  1029.   Pint lev;
  1030.  
  1031.   r = topptr->rowlist;
  1032.   lev = 1;
  1033.   *last = NULL;
  1034.   while (r != NULL && lev != l) 
  1035.   {
  1036.     *last = r;
  1037.     r = r->next;
  1038.     lev++;
  1039.   }
  1040.   return r;
  1041. }  /* selectrow */
  1042.  
  1043. /*--------------------------------------------------------------------------*/
  1044.  
  1045. static void addtorowlist(C(ptksstruct *) sp, C(Pint) level)
  1046. PreANSI(ptksstruct *sp)
  1047. PreANSI(Pint level)
  1048. /*
  1049. ** \blurb{Adds an entry for `sp' to the `level'th row; also records
  1050. ** the level in the structure entry.}
  1051. */
  1052. {
  1053.   ptksrow *last, *r, *newr;
  1054.   ptksnode *np, *newnp, *lastnp;
  1055.  
  1056.   r = selectrow(level, &last);
  1057.   if (r == NULL) 
  1058.   {   
  1059.     /* the required level doesn't yet exist */
  1060.     newr = (ptksrow *)malloc(sizeof(ptksrow));
  1061.     if (last == NULL)
  1062.       topptr->rowlist = newr;
  1063.     else
  1064.       last->next = newr;
  1065.     newr->next = NULL;
  1066.     newr->num = 0;
  1067.     newr->n = NULL;
  1068.     r = newr;
  1069.   }
  1070.  
  1071.   /* So now we are at the start of a row list, which may
  1072.      or may not be empty. Add the new node to the tail of it*/
  1073.   np = r->n;
  1074.   lastnp = NULL;
  1075.   r->num++;
  1076.   while (np != NULL) 
  1077.   {
  1078.     lastnp = np;
  1079.     np = np->next;
  1080.   }
  1081.   /* now lastnp = tail */
  1082.   newnp = (ptksnode *)malloc(sizeof(ptksnode));   /*create the new node*/
  1083.   if (lastnp == NULL)   /*chain to tail*/
  1084.     r->n = newnp;   /*chain to row header*/
  1085.   else
  1086.     lastnp->next = newnp;
  1087.   newnp->structptr = sp;
  1088.   newnp->next = NULL;
  1089.   sp->level = level;
  1090.  
  1091.   /* keep track of the maximum level */
  1092.   if (level > topptr->maxlevel)
  1093.     topptr->maxlevel = level;
  1094. }  /* addtorowlist */
  1095.  
  1096. /*--------------------------------------------------------------------------*/
  1097.  
  1098. static ptksnode *selectrownode(C(ptksrow *) r, C(ptksstruct *) sp, C(ptksnode **)last)
  1099. PreANSI(ptksrow *r)
  1100. PreANSI(ptksstruct *sp)
  1101. PreANSI(ptksnode **last)
  1102. /*
  1103. ** \blurb{Locates the given structure in the given row. It's address
  1104. ** is returned as the result. Also, if there is a node immediately
  1105. ** previous to this node, its address is returned in 'last',
  1106. ** otherwise 'last' is NIL, which means that the first node in
  1107. ** the row list was found.}
  1108. */
  1109. { 
  1110.   ptksnode *np;
  1111.   ptkboolean found;
  1112.  
  1113.   np = r->n;
  1114.   found = FALSE;
  1115.   *last = NULL;
  1116.   while (np != NULL && !found) 
  1117.   {
  1118.     if (np->structptr == sp)
  1119.       found = TRUE;
  1120.     else 
  1121.     {
  1122.       *last = np;   /* record the previous address */
  1123.       np = np->next;
  1124.     }
  1125.   }
  1126.   return np;
  1127. }  /* selectrownode */
  1128.  
  1129. /*--------------------------------------------------------------------------*/
  1130.  
  1131. static void deletefromrowlist(C(ptksstruct *) sp)
  1132. PreANSI(ptksstruct *sp)
  1133. /*
  1134. ** \blurb{Deletes the entry for sp from its row.}
  1135. */
  1136. {
  1137.   ptksrow *r, *dummy;
  1138.   ptksnode *np, *last;
  1139.  
  1140.   r = selectrow(sp->level, &dummy);
  1141.   if (r == NULL) 
  1142.   {
  1143. /*    printf("deletefromrowlist: row %d doesn't exist\n", sp->level); */
  1144.     return;
  1145.   }
  1146.   r->num--;
  1147.   np = selectrownode(r, sp, &last);
  1148.   if (np == NULL) 
  1149.   {
  1150. /*    printf("deletefromrowlist: %d not found on row %d\n",
  1151.        sp->name, sp->level); */
  1152.     return;
  1153.   }
  1154.   if (last == NULL)
  1155.     r->n = np->next;   /* first on the list */
  1156.   else
  1157.     last->next = np->next;
  1158.   free(np);
  1159. }  /* deletefromrowlist */
  1160.  
  1161. /*--------------------------------------------------------------------------*/
  1162.  
  1163. static void getpaths()
  1164. {
  1165.   Pint totsize, err;
  1166.  
  1167.   pcreate_store(&err, &topptr->pathdata);
  1168.   pinq_paths_descs(topptr->root, PORDER_TOP_FIRST, 0, topptr->pathdata,
  1169.                    &err, &topptr->pathlist);
  1170. }
  1171.  
  1172. /*--------------------------------------------------------------------------*/
  1173.  
  1174. static void buildlists(C(void))
  1175. /*
  1176. ** \blurb{Constructs the main data structures used by the topology 
  1177. ** drawer. It creates the structure list, and the row list.}
  1178. */
  1179. {
  1180.   Pint cur_level, p, path;
  1181.   ptksstruct *sp;
  1182.   ptkboolean rowentryinvalid;
  1183.  
  1184.   /* do first node */
  1185.   lookupstructure(topptr->root, TRUE, &sp);
  1186.   addtorowlist(sp, 1);
  1187.   for (p = 0; p < topptr->pathlist->num_elem_ref_lists; p++) 
  1188.   {  
  1189.     /* do a path */
  1190.     cur_level = 1;
  1191.     for (path = 0; path < topptr->pathlist->elem_ref_lists[p].num_elem_refs;
  1192.          path++) 
  1193.     {   
  1194.       /* each member of path */
  1195.       rowentryinvalid = TRUE;   /* assume it will change the row list */
  1196.       /* Look for this structure, and create it if it isn't there */
  1197.       if (!lookupstructure(topptr->pathlist->elem_ref_lists[p].elem_refs[path].struct_id, TRUE, &sp)) 
  1198.       {
  1199.     /* it was already there */
  1200.     if (sp->level < cur_level)
  1201.       deletefromrowlist(sp);
  1202.     else
  1203.       rowentryinvalid = FALSE;
  1204.       }
  1205.       if (rowentryinvalid)
  1206.     addtorowlist(sp, cur_level);
  1207.       cur_level++;
  1208.     }  /* each member of path */
  1209.     /* go to next path  */
  1210.   }  /* a path */
  1211.   storereferences();
  1212.   ptk_delstore(topptr->pathdata);
  1213. }  /* buildlists */
  1214.  
  1215. /*--------------------------------------------------------------------------*/
  1216.  
  1217.  
  1218. static void disposenodelist(C(ptksnode *) nodeptr)
  1219. PreANSI(ptksnode *nodeptr)
  1220. {
  1221.   if (nodeptr->next == NULL)
  1222.     free(nodeptr);
  1223.   else
  1224.     disposenodelist(nodeptr->next);
  1225. }
  1226.  
  1227. /*--------------------------------------------------------------------------*/
  1228.  
  1229. static void disposereflist(C(ptksref *) refptr)
  1230. PreANSI(ptksref *refptr)
  1231. {
  1232.   if (refptr->next == NULL)
  1233.     free(refptr);
  1234.   else
  1235.     disposereflist(refptr->next);
  1236. }
  1237.  
  1238. /*--------------------------------------------------------------------------*/
  1239.  
  1240. static void disposestructlist(C(ptksstruct *) stptr)
  1241. PreANSI(ptksstruct *stptr)
  1242. {
  1243.   if (stptr->next == NULL)
  1244.   {
  1245.     if (stptr->firstchild != NULL)
  1246.       disposereflist(stptr->firstchild);
  1247.     if (stptr->firstparent != NULL)
  1248.       disposereflist(stptr->firstparent);
  1249.     free(stptr);
  1250.   }
  1251.   else
  1252.     disposestructlist(stptr->next);
  1253. }
  1254.  
  1255. /*--------------------------------------------------------------------------*/
  1256.  
  1257. static void disposerowlist(C(ptksrow *) rowptr)
  1258. PreANSI(ptksrow *rowptr)
  1259. {
  1260.   if (rowptr->next == NULL)
  1261.   {
  1262.     if (rowptr->n != NULL)
  1263.       disposenodelist(rowptr->n);
  1264.     free(rowptr);
  1265.   }
  1266.   else
  1267.     disposerowlist(rowptr->next);
  1268. }
  1269.  
  1270. /*--------------------------------------------------------------------------*/
  1271.  
  1272. static inqnamelist(C(ptksstruct *) stptr, C(Pint_list *) namelist)
  1273. PreANSI(ptksstruct *stptr)
  1274. PreANSI(Pint_list *namelist)
  1275. {
  1276.   ptksref *refptr;
  1277.  
  1278.   refptr = stptr->firstchild;
  1279.   while (refptr != NULL)
  1280.   {
  1281.     if (inintlst(refptr->structptr->name, namelist) == -1)
  1282.       namelist->ints[namelist->num_ints++] = refptr->structptr->name;
  1283.     inqnamelist(refptr->structptr, namelist);
  1284.     refptr = refptr->next;
  1285.   }
  1286. }
  1287.  
  1288. /*--------------------------------------------------------------------------*/
  1289.  
  1290. static void setnodeposition(C(Pint) topid, C(Pint) nodeid, 
  1291.                                C(Ppoint *) nodept, C(ptkenodetype) nodetype)
  1292. PreANSI(Pint topid)
  1293. PreANSI(Pint nodeid)
  1294. PreANSI(Ppoint *nodept)
  1295. PreANSI(ptkenodetype nodetype)
  1296. {
  1297.   ptksstruct *structptr;
  1298.   Pint err, i, totsize;
  1299.   Ppoint3 toppt, nodept3;
  1300.   Pmatrix3 invglobalmat;
  1301.   Ppoint3 delta;
  1302.   Pint_list stids, nameset;
  1303.   Pint ids[255], name;
  1304.  
  1305.   settop(topid);
  1306.   ptk_invertmatrix3(topptr->globaltran, invglobalmat, &err);
  1307.   nodept3 = ptk_point3(nodept->x, nodept->y, 0.0);
  1308.   toppt = ptk_transform3(invglobalmat, &nodept3);
  1309.   switch (nodetype)
  1310.   {
  1311.     case PTKESINGLE: 
  1312.       structptr = topptr->structlist;
  1313.       for (i = 0; i < nodeid; i++)
  1314.         structptr = structptr->next;
  1315.       structptr->pos = ptk_point(toppt.x, toppt.y);
  1316.       break;
  1317.    
  1318.     case PTKEGROUP:
  1319.       /* calculate dx, dy,
  1320.          follow ref list, add dx, dy to position
  1321.       */
  1322.       structptr = topptr->structlist;
  1323.       for (i = 0; i < nodeid; i++)
  1324.         structptr = structptr->next;
  1325.       delta = ptk_point3(toppt.x - structptr->pos.x,
  1326.                          toppt.y - structptr->pos.y, 0.0);
  1327.       /* inquire structure identifiers of sub tree */
  1328.       stids.ints = ids;
  1329.       stids.num_ints = 1;
  1330.       ids[0] = structptr->name;
  1331.       inqnamelist(structptr, &stids);
  1332.       for (i = 0; i < stids.num_ints; i++)
  1333.       {
  1334.         structptr = topptr->structlist;
  1335.         while (structptr->name != stids.ints[i])
  1336.           structptr = structptr->next;
  1337.         structptr->pos.x += delta.x;
  1338.         structptr->pos.y += delta.y;
  1339.       }
  1340.       break;
  1341.   }
  1342.   /* remove keys */
  1343.   topptr->keyno = 0;
  1344.   for (i = 0; i <= 254; i++)
  1345.     topptr->rowmaxx[i] = -32768.0;
  1346.   ptk_openstruct(topptr->topologystid);
  1347.   pset_elem_ptr(0);
  1348.   pdel_elems_labels(ptk_stringtoint("label", "globaltran"), 
  1349.                   ptk_stringtoint("label", "highlightattrs"));
  1350.   pdel_elems_labels(ptk_stringtoint("label", "highlightnode"), 
  1351.                   ptk_stringtoint("label", "attrs"));
  1352.   pdel_elems_labels(ptk_stringtoint("label", "starttopology"), 
  1353.                   ptk_stringtoint("label", "endtopology"));
  1354.   topptr->extent = ptk_limit3(1000000.0, -10000000.0, 10000000.0,
  1355.                                -10000000.0, 0.0, 1.0);
  1356.   pset_edit_mode(PEDIT_INSERT);  
  1357.   setnode(1.0, 1.0);
  1358.   switch (topptr->topologytype)
  1359.   {
  1360.     case PTKEBOXTOPOLOGY: 
  1361.       drawnodes();
  1362.       break;
  1363.  
  1364.     case PTKESTRUCTNETTOPOLOGY:
  1365.       drawstructnetnodes();
  1366.       break;
  1367.  
  1368.     case PTKESTRUCTTOPOLOGY:
  1369.       drawstructnodes();
  1370.       break;
  1371.   }
  1372.   nameset.ints = &name;
  1373.   nameset.num_ints = 1;
  1374.   name = topptr->topologyname;
  1375.   premove_names_set(&nameset);
  1376.   drawconnections();
  1377.   drawnames();
  1378.   drawkeys();
  1379.   setscaling();
  1380.   ptk_closestruct();
  1381. }  /* setnodeposition */
  1382.  
  1383. /*--------------------------------------------------------------------------*/
  1384.  
  1385. static void redrawtopology(C(void))
  1386. {
  1387.   Pint_list nameset;
  1388.   Pint name, k;
  1389.  
  1390.   /* remove keys */
  1391.   topptr->keyno = 0;
  1392.   for (k = 0; k <= 254; k++)
  1393.     topptr->rowmaxx[k] = -32768.0;
  1394.   pempty_struct(topptr->topologystid);
  1395.   ptk_openstruct(topptr->topologystid);
  1396.   
  1397.   ptk_seteditmode(PEDIT_INSERT);   /* We want to insert elements */
  1398.   nameset.ints = &name;
  1399.   nameset.num_ints = 1;
  1400.   name = topptr->topologyname;
  1401.   padd_names_set(&nameset);
  1402.   plabel(ptk_stringtoint("label", "globaltran"));
  1403.  
  1404.   plabel(ptk_stringtoint("label", "highlightattrs"));
  1405.   pset_edge_colr_ind(topptr->highlightedge);
  1406.   pset_int_colr_ind(topptr->highlightint);
  1407.   pset_int_style(PSTYLE_SOLID);
  1408.   pset_edge_flag(PEDGE_ON);
  1409.   plabel(ptk_stringtoint("label", "highlightnode"));
  1410.   plabel(ptk_stringtoint("label", "attrs"));
  1411.   pset_line_colr_ind(topptr->linecolour);
  1412.   pset_int_colr_ind(topptr->intcolour);
  1413.   pset_edge_colr_ind(topptr->edgecolour);
  1414.   pset_text_font(topptr->txfont);
  1415.   pset_text_colr_ind(topptr->textcolour);
  1416.   plabel(ptk_stringtoint("label", "starttopology"));
  1417.  
  1418.   placenodes();
  1419.   switch (topptr->topologytype)
  1420.   {
  1421.     case PTKEBOXTOPOLOGY: 
  1422.       drawnodes();
  1423.       break;
  1424.  
  1425.     case PTKESTRUCTNETTOPOLOGY:
  1426.       drawstructnetnodes();
  1427.       break;
  1428.  
  1429.     case PTKESTRUCTTOPOLOGY:
  1430.       drawstructnodes();
  1431.       break;
  1432.   }
  1433.   premove_names_set(&nameset);
  1434.   drawconnections();
  1435.   drawnames();
  1436.  
  1437.   /* In case any nodes were labelled with keys because there was no room
  1438.      for proper annotation, draw the keytable. */
  1439.   drawkeys();
  1440.   plabel(ptk_stringtoint("label", "endtopology"));
  1441.  
  1442.   /* now we've drawn it all, so we find the appropriate scale to put it all
  1443.      in [0,1] */
  1444.   setscaling();
  1445.  
  1446.   ptk_unseteditmode();
  1447.   ptk_closestruct();    
  1448. }  /* redrawtopology */
  1449.  
  1450. /*--------------------------------------------------------------------------*/
  1451. /*--------------------- External Topology Functions ------------------------*/
  1452. /*--------------------------------------------------------------------------*/
  1453.  
  1454. static void createtopology(C(Pint) topid, C(Pint) root, C(Pint) txfont,
  1455.                          C(Pint) linecol, C(Pint) textcol, C(Pint) edgecol,
  1456.                          C(Pint) intcol, C(Pint *) error)
  1457. PreANSI(Pint topid)
  1458. PreANSI(Pint root)
  1459. PreANSI(Pint txfont)
  1460. PreANSI(Pint linecol)
  1461. PreANSI(Pint textcol)
  1462. PreANSI(Pint edgecol)
  1463. PreANSI(Pint intcol)
  1464. PreANSI(Pint *error)
  1465. /* 
  1466. ** \parambegin
  1467. ** \param{Pint}{topid}{topology identifier}{IN}
  1468. ** \param{Pint}{root}{structure network identifier}{IN}
  1469. ** \param{Pint}{txfont}{label text font}{IN}
  1470. ** \param{Pint}{linecol}{polyline colour index}{IN}
  1471. ** \param{Pint}{textcol}{text colour index}{IN}
  1472. ** \param{Pint}{edgecol}{edge colour index}{IN}
  1473. ** \param{Pint}{intcol}{interior colour index}{IN}
  1474. ** \param{Pint *}{error}{error code}{OUT}
  1475. ** \paramend
  1476. ** \blurb{Create topology diagram of given structure network.}
  1477. */
  1478. {
  1479.   Pint curname;
  1480.   char stname[255];
  1481.   Pint_list nameset;
  1482.   Pint name;
  1483.  
  1484.   /* if there already exists a topology with this identifier, error */
  1485.   *error = 0;
  1486.   settop(topid);
  1487.   if (topptr == NULL)
  1488.   {  
  1489.     if (lasttop == NULL)
  1490.     {
  1491.       firsttop = lasttop = topptr =
  1492.         (ptkstopdraw *)malloc(sizeof(ptkstopdraw));
  1493.       topptr->next = NULL;
  1494.     }
  1495.     else
  1496.     {
  1497.       lasttop->next = topptr = (ptkstopdraw *)malloc(sizeof(ptkstopdraw));
  1498.       topptr->next = NULL;
  1499.       lasttop = lasttop->next;
  1500.     }
  1501.  
  1502.     topologycount++;  
  1503.     topptr->topologyid = topid;
  1504.     topptr->posted.num_ints = 0;
  1505.     topptr->posted.ints = (Pint *)calloc(10, sizeof(Pint));
  1506.     sprintf(stname, "ptk$topology%d", topid);
  1507.     topptr->topologystid = ptk_stringtoint("structureid", stname);
  1508.     sprintf(stname, "name$topology%d", topid);
  1509.     topptr->topologyname = ptk_stringtoint("name", stname);
  1510.     topptr->root = root;
  1511.     topptr->topologytype = PTKEBOXTOPOLOGY;
  1512.     topptr->txfont = txfont;
  1513.     topptr->textcolour = textcol;
  1514.     topptr->linecolour = linecol;
  1515.     topptr->edgecolour = edgecol;
  1516.     topptr->intcolour = intcol;
  1517.     topptr->highlightnode = -1;
  1518.     topptr->highlightedge = intcol;
  1519.     topptr->highlightint = edgecol;
  1520.     *error = 0;
  1521.   
  1522.     if (!ptk_structexists(topptr->root)) 
  1523.     {
  1524.       *error = 1;
  1525.       fprintf(stderr, "ptk_createtopology: structure [%d] doesn't exist\n", topptr->root);
  1526.       return;
  1527.     }
  1528.   
  1529.     ptk_openstruct(topptr->topologystid);
  1530.     
  1531.     initialise();
  1532.     getpaths();
  1533.     buildlists();
  1534.   
  1535.     ptk_seteditmode(PEDIT_INSERT);   /* We want to insert elements */
  1536.     nameset.ints = &name;
  1537.     nameset.num_ints = 1;
  1538.     name = topptr->topologyname;
  1539.     padd_names_set(&nameset);
  1540.     plabel(ptk_stringtoint("label", "globaltran"));
  1541.     plabel(ptk_stringtoint("label", "highlightattrs"));
  1542.     pset_edge_colr_ind(topptr->highlightedge);
  1543.     pset_int_colr_ind(topptr->highlightint);  
  1544.     pset_int_style(PSTYLE_SOLID);
  1545.     pset_edge_flag(PEDGE_ON);
  1546.     plabel(ptk_stringtoint("label", "highlightnode"));
  1547.     plabel(ptk_stringtoint("label", "attrs"));
  1548.     pset_line_colr_ind(topptr->linecolour);
  1549.     pset_int_colr_ind(topptr->intcolour);
  1550.     pset_edge_colr_ind(topptr->edgecolour);
  1551.     pset_text_font(topptr->txfont);
  1552.     pset_text_colr_ind(topptr->textcolour);
  1553.     plabel(ptk_stringtoint("label", "starttopology"));
  1554.   
  1555.     placenodes();
  1556.     drawnodes();  
  1557.     premove_names_set(&nameset);
  1558.     drawconnections();
  1559.     drawnames();
  1560.   
  1561.     /* In case any nodes were labelled with keys because there was no room
  1562.        for proper annotation, draw the keytable. */
  1563.     drawkeys();
  1564.     plabel(ptk_stringtoint("label", "endtopology"));
  1565.  
  1566.     /* now we've drawn it all, so we find the appropriate scale to put it all
  1567.        in [0,1] */
  1568.     setscaling();
  1569.   
  1570.     ptk_unseteditmode();
  1571.     ptk_closestruct();
  1572.   }
  1573.   else
  1574.   {
  1575.     *error = 2;
  1576.   }
  1577. }  /* createtopology */
  1578.  
  1579. /*--------------------------------------------------------------------------*/
  1580.  
  1581. /*function:external*/
  1582. extern void ptk_createtopology(C(Pint) topid, C(Pint) root, C(Pint *) err)
  1583. PreANSI(Pint topid)
  1584. PreANSI(Pint root)
  1585. PreANSI(Pint *err)
  1586. /* 
  1587. ** \parambegin
  1588. ** \param{Pint}{topid}{topology identifier}{IN}
  1589. ** \param{Pint}{root}{structure network identifier}{IN}
  1590. ** \param{Pint *}{error}{error code}{OUT}
  1591. ** \paramend
  1592. ** \blurb{This function creates a diagram of the structure network
  1593. ** specified by {\tt root}. The diagram is a PHIGS structure which
  1594. ** uses boxes connected by lines to represent structures and
  1595. ** EXECUTE STRUCTURE elements. The error code = 1 if the root structure
  1596. ** does not exist and = 2 if {\tt topid} already exists.
  1597. ** This function requires hashtables "structureid", "label", "name".} 
  1598. */
  1599. {
  1600.   createtopology(topid, root, 1, 1, 1, 1, 0, err);
  1601. }  /* ptk_createtopology */
  1602.  
  1603. /*--------------------------------------------------------------------------*/
  1604.  
  1605. /*function:external*/
  1606. extern void ptk_settopologyattrs(C(Pint) topid, C(Pint) txfont,
  1607.                          C(Pint) linecol, C(Pint) textcol, C(Pint) edgecol,
  1608.                          C(Pint) intcol, C(Pint) htedgecol, C(Pint) htintcol)
  1609. PreANSI(Pint topid)
  1610. PreANSI(Pint txfont)
  1611. PreANSI(Pint linecol)
  1612. PreANSI(Pint textcol)
  1613. PreANSI(Pint edgecol)
  1614. PreANSI(Pint intcol)
  1615. PreANSI(Pint htedgecol)
  1616. PreANSI(Pint htintcol)
  1617. /* 
  1618. ** \parambegin
  1619. ** \param{Pint}{topid}{topology identifier}{IN}
  1620. ** \param{Pint}{txfont}{label text font}{IN}
  1621. ** \param{Pint}{linecol}{polyline colour index}{IN}
  1622. ** \param{Pint}{textcol}{text colour index}{IN}
  1623. ** \param{Pint}{edgecol}{edge colour index}{IN}
  1624. ** \param{Pint}{intcol}{interior colour index}{IN}
  1625. ** \param{Pint}{htedgecol}{highlight edge colour index}{IN}
  1626. ** \param{Pint}{htintcol}{highlight interior colour index}{IN}
  1627. ** \paramend
  1628. ** \blurb{This function sets the text font and colour attribute values 
  1629. ** of a topology diagram. The text font applies to the structure
  1630. ** names which are extracted from the \"structureid\" hashtable.
  1631. ** The highlight colour indicies are used to highlight a single
  1632. ** topology node in the function {\tt ptk\_settopologyhighlightnode}.}
  1633. */
  1634. {
  1635.   settop(topid);
  1636.   if (topptr != NULL)
  1637.   {  
  1638.     topptr->txfont = txfont;
  1639.     topptr->textcolour = textcol;
  1640.     topptr->linecolour = linecol;
  1641.     topptr->edgecolour = edgecol;
  1642.     topptr->intcolour = intcol;
  1643.     topptr->highlightedge = htedgecol;
  1644.     topptr->highlightint = htintcol;
  1645.     redrawtopology();
  1646.   }
  1647. }  /* ptk_settopologyattrs */
  1648.  
  1649. /*--------------------------------------------------------------------------*/
  1650.  
  1651. /*function:external*/
  1652. extern void ptk_inqtopologyattrs(C(Pint) topid, C(Pint *) txfont,
  1653.                   C(Pint *) linecol, C(Pint *) textcol, C(Pint *) edgecol,
  1654.                   C(Pint *) intcol, C(Pint *) htedgecol, C(Pint *) htintcol,
  1655.                   C(Pint *) err)
  1656. PreANSI(Pint topid)
  1657. PreANSI(Pint *txfont)
  1658. PreANSI(Pint *linecol)
  1659. PreANSI(Pint *textcol)
  1660. PreANSI(Pint *edgecol)
  1661. PreANSI(Pint *intcol)
  1662. PreANSI(Pint *htedgecol)
  1663. PreANSI(Pint *htintcol)
  1664. PreANSI(Pint *err)
  1665. /* 
  1666. ** \parambegin
  1667. ** \param{Pint}{topid}{topology identifier}{IN}
  1668. ** \param{Pint *}{txfont}{label text font}{OUT}
  1669. ** \param{Pint *}{linecol}{polyline colour index}{OUT}
  1670. ** \param{Pint *}{textcol}{text colour index}{OUT}
  1671. ** \param{Pint *}{edgecol}{edge colour index}{OUT}
  1672. ** \param{Pint *}{intcol}{interior colour index}{OUT}
  1673. ** \param{Pint *}{htedgecol}{highlight edge colour index}{OUT}
  1674. ** \param{Pint *}{htintcol}{highlight interior colour index}{OUT}
  1675. ** \param{Pint *}{err}{error indicator}{OUT}
  1676. ** \paramend
  1677. ** \blurb{This function may be used to obtain the text font and
  1678. ** colour attribute values of a topology diagram. The error code = 1
  1679. ** if {\tt topid} doesn't exist.}
  1680. */
  1681. {
  1682.   *err = 0;
  1683.   settop(topid);
  1684.   if (topptr != NULL)
  1685.   {  
  1686.     *txfont = topptr->txfont;
  1687.     *textcol = topptr->textcolour;
  1688.     *linecol = topptr->linecolour;
  1689.     *edgecol = topptr->edgecolour;
  1690.     *intcol = topptr->intcolour;
  1691.     *htedgecol = topptr->highlightedge;
  1692.     *htintcol = topptr->highlightint;
  1693.     redrawtopology();
  1694.   }
  1695.   else
  1696.     *err = 1;
  1697. }  /* ptk_inqtopologyattrs */
  1698.  
  1699. /*--------------------------------------------------------------------------*/
  1700.  
  1701. /*function:external*/
  1702. extern void ptk_createtopologypaths(C(Pint) topid, 
  1703.                      C(Pelem_ref_list_list *) paths, C(Pint *) error)
  1704. PreANSI(Pint topid)
  1705. PreANSI(Pelem_ref_list_list *paths)
  1706. PreANSI(Pint *error)
  1707. /* 
  1708. ** \parambegin
  1709. ** \param{Pint}{topid}{topology identifier}{IN}
  1710. ** \param{Pelem\_ref\_list\_list *}{paths}{structure-element paths}{IN}
  1711. ** \param{Pint *}{error}{error code}{OUT}
  1712. ** \paramend
  1713. ** \blurb{This function creates a topology diagram using the structure
  1714. ** path list {\tt paths}. This enables a topology diagram to be built
  1715. ** of a non-existent structure network or of a subset of an actual
  1716. ** structure network. The error code = 1 if {\tt topid} already exists.
  1717. ** This function requires hashtables "structureid", "label", "name".} 
  1718. */
  1719. {
  1720.   Pint curname;
  1721.   char stname[255];
  1722.   Pint_list nameset;
  1723.   Pint name;
  1724.  
  1725.   *error = 0;
  1726.   settop(topid);
  1727.   if (topptr == NULL)
  1728.   {
  1729.     if (lasttop == NULL)
  1730.     {
  1731.       firsttop = lasttop = topptr =
  1732.         (ptkstopdraw *)malloc(sizeof(ptkstopdraw));
  1733.       topptr->next = NULL;
  1734.     }
  1735.     else
  1736.     {
  1737.       lasttop->next = topptr = (ptkstopdraw *)malloc(sizeof(ptkstopdraw));
  1738.       topptr->next = NULL;
  1739.       lasttop = lasttop->next;
  1740.     }
  1741.  
  1742.     topologycount++;  
  1743.     topptr->topologyid = topid;
  1744.     topptr->posted.num_ints = 0;
  1745.     topptr->posted.ints = (Pint *)calloc(10, sizeof(Pint));
  1746.     sprintf(stname, "ptk$topology%d", topid);
  1747.     topptr->topologystid = ptk_stringtoint("structureid", stname);
  1748.     sprintf(stname, "name$topology%d", topid);
  1749.     topptr->topologyname = ptk_stringtoint("name", stname);
  1750.     topptr->topologytype = PTKEBOXTOPOLOGY;
  1751.     topptr->txfont = 1;
  1752.     topptr->textcolour = 1;
  1753.     topptr->linecolour = 1;
  1754.     topptr->edgecolour = 1;
  1755.     topptr->intcolour = 0;
  1756.     topptr->highlightnode = -1;
  1757.     topptr->highlightedge = 0;
  1758.     topptr->highlightint = 1;
  1759.   
  1760.     if (paths->num_elem_ref_lists > 0)
  1761.     {
  1762.       topptr->root = paths->elem_ref_lists[0].elem_refs[0].struct_id;
  1763.   
  1764.       ptk_openstruct(topptr->topologystid);  
  1765.       initialise();
  1766.       topptr->pathlist = paths;
  1767.       buildlists();
  1768.     
  1769.       ptk_seteditmode(PEDIT_INSERT);   /* We want to insert elements */
  1770.       nameset.ints = &name;
  1771.       nameset.num_ints = 1;
  1772.       name = topptr->topologyname;
  1773.       padd_names_set(&nameset);  
  1774.       plabel(ptk_stringtoint("label", "globaltran"));
  1775.  
  1776.       plabel(ptk_stringtoint("label", "highlightattrs"));
  1777.       pset_edge_colr_ind(topptr->highlightedge);
  1778.       pset_int_colr_ind(topptr->highlightint);    
  1779.       pset_int_style(PSTYLE_SOLID);
  1780.       pset_edge_flag(PEDGE_ON);
  1781.       plabel(ptk_stringtoint("label", "highlightnode"));
  1782.       plabel(ptk_stringtoint("label", "attrs"));
  1783.       pset_line_colr_ind(topptr->linecolour);
  1784.       pset_int_colr_ind(topptr->intcolour);
  1785.       pset_edge_colr_ind(topptr->edgecolour);
  1786.       pset_text_font(topptr->txfont);
  1787.       pset_text_colr_ind(topptr->textcolour);
  1788.       plabel(ptk_stringtoint("label", "starttopology"));
  1789.     
  1790.       placenodes();
  1791.       drawnodes();
  1792.       premove_names_set(&nameset);
  1793.       drawconnections();
  1794.       drawnames();
  1795.     
  1796.       /* In case any nodes were labelled with keys because there was no room
  1797.          for proper annotation, draw the keytable. */
  1798.       drawkeys();
  1799.       plabel(ptk_stringtoint("label", "endtopology"));
  1800.  
  1801.       /* now we've drawn it all, so we find the appropriate scale to put it all
  1802.          in [0,1] */
  1803.       setscaling();
  1804.     
  1805.       ptk_unseteditmode();
  1806.       ptk_closestruct();
  1807.     }
  1808.   }
  1809.   else
  1810.     *error = 1;
  1811. }  /* ptk_createtopologypaths */
  1812.  
  1813. /*--------------------------------------------------------------------------*/
  1814.  
  1815. /*function:external*/
  1816. extern void ptk_settopologytype(C(Pint) topid, C(ptketopologytype) toptype)
  1817. PreANSI(Pint topid)
  1818. PreANSI(ptketopologytype toptype)
  1819. /*
  1820. ** \parambegin
  1821. ** \param{Pint}{topid}{topology identifier}{IN}
  1822. ** \param{ptketopologytype}{toptype}{topology type}{IN}
  1823. ** \paramend
  1824. ** \blurb{This function sets the type of a topology diagram to 
  1825. ** BOX, STRUCT or STRUCTNET. The BOX topology type is the default and
  1826. ** the STRUCT and STRUCTNET types insert parts of the actual structures
  1827. ** into the nodes. As a result these topology types do not work well
  1828. ** for networks containing SET VIEW INDEX and SET GLOBAL TRANSFORMATION
  1829. ** elements.}
  1830. */
  1831. {
  1832.   settop(topid);
  1833.   if (topptr != NULL)
  1834.   {
  1835.     if (topptr->topologytype != toptype)
  1836.     {
  1837.       if (topptr->topologytype == PTKESTRUCTTOPOLOGY)
  1838.         delstructnodes();
  1839.       topptr->topologytype = toptype;
  1840.       redrawtopology();
  1841.     }
  1842.   }
  1843. }  /* ptk_settopologytype */
  1844.  
  1845. /*--------------------------------------------------------------------------*/
  1846.  
  1847. /*function:external*/
  1848. extern void ptk_inqtopologytype(C(Pint) topid, C(ptketopologytype *) toptype,
  1849.                                 C(Pint *) err)
  1850. PreANSI(Pint topid)
  1851. PreANSI(ptketopologytype *toptype)
  1852. PreANSI(Pint *err)
  1853. /*
  1854. ** \parambegin
  1855. ** \param{Pint}{topid}{topology identifier}{IN}
  1856. ** \param{ptketopologytype *}{toptype}{topology type}{OUT}
  1857. ** \param{Pint *}{err}{error indicator}{OUT}
  1858. ** \paramend
  1859. ** \blurb{This function may be used to obtain the type of a topology
  1860. ** diagram. The possible types are BOX, STRUCT and STRUCTNET, with BOX
  1861. ** as the default. The error code = 1 if {\tt topid} doesn't exist.}
  1862. */
  1863. {
  1864.   *err = 0;
  1865.   settop(topid);
  1866.   if (topptr != NULL)
  1867.   {
  1868.     *toptype = topptr->topologytype;
  1869.   }
  1870.   else
  1871.     *err = 1;
  1872. }  /* ptk_inqtopologytype */
  1873.  
  1874. /*--------------------------------------------------------------------------*/
  1875.  
  1876. /*function:external*/
  1877. extern void ptk_setnodeposition(C(Pint) topid, C(Pint) structid, 
  1878.                                C(Ppoint *) nodept, C(ptkenodetype) nodetype)
  1879. PreANSI(Pint topid)
  1880. PreANSI(Pint structid)
  1881. PreANSI(Ppoint *nodept)
  1882. PreANSI(ptkenodetype nodetype)
  1883. /*
  1884. ** \parambegin
  1885. ** \param{Pint}{topid}{topology identifier}{IN}
  1886. ** \param{Pint}{structid}{structure identifier}{IN}
  1887. ** \param{Ppoint *}{nodept}{node position}{IN}
  1888. ** \param{ptkenodetype}{nodetype}{type of node}{IN}
  1889. ** \paramend
  1890. ** \blurb{This function sets the position of a topology node or group
  1891. ** of nodes. The position is given in the range [0, 1].
  1892. ** The node is specified using the structure identifier of the structure
  1893. ** that it represents. If nodetype is set to GROUP then all descendent
  1894. ** nodes of {\tt structid} are moved relative to it.}
  1895. */
  1896. {
  1897.   ptksstruct *structptr;
  1898.   Pint nodeid;
  1899.   ptkboolean found;
  1900.  
  1901.   nodeid = 0;
  1902.   settop(topid);
  1903.   if (topptr != NULL)
  1904.   {
  1905.     structptr = topptr->structlist;
  1906.     found = FALSE;
  1907.     while ((!found) && (structptr != NULL))
  1908.     {
  1909.       if (structptr->name == structid)
  1910.         found = TRUE;
  1911.       else
  1912.         nodeid++;
  1913.       structptr = structptr->next;
  1914.     }
  1915.     if (found)
  1916.       setnodeposition(topid, nodeid, nodept, nodetype);
  1917.   }
  1918. }  /* ptk_setnodeposition */
  1919.  
  1920. /*--------------------------------------------------------------------------*/
  1921.  
  1922. /*function:external*/
  1923. extern void ptk_inqnodeposition(C(Pint) topid, C(Pint) structid, 
  1924.                                C(Ppoint *) nodept, C(Pint *) err)
  1925. PreANSI(Pint topid)
  1926. PreANSI(Pint structid)
  1927. PreANSI(Ppoint *nodept)
  1928. PreANSI(Pint *err)
  1929. /*
  1930. ** \parambegin
  1931. ** \param{Pint}{topid}{topology identifier}{IN}
  1932. ** \param{Pint}{structid}{structure identifier}{IN}
  1933. ** \param{Ppoint *}{nodept}{node position}{OUT}
  1934. ** \param{Pint *}{err}{error indicator}{OUT}
  1935. ** \paramend
  1936. ** \blurb{This function may be used to obtain the position of a topology 
  1937. ** node in a topology diagram. The position is returned in the range [0, 1]. 
  1938. ** The node is specified using the structure
  1939. ** identifier of the structure that it represents. The error code = 1
  1940. ** if {\tt topid} doesn't exist and = 2 if {\tt structid} is not a node
  1941. ** in the topology.}
  1942. */
  1943. {
  1944.   ptksstruct *structptr;
  1945.   Pint nodeid;
  1946.   Ppoint3 nodept3;
  1947.   ptkboolean found;
  1948.  
  1949.   *err = 0;
  1950.   nodeid = 0;
  1951.   settop(topid);
  1952.   if (topptr != NULL)
  1953.   {
  1954.     structptr = topptr->structlist;
  1955.     found = FALSE;
  1956.     while ((!found) && (structptr != NULL))
  1957.     {
  1958.       if (structptr->name == structid)
  1959.         found = TRUE;
  1960.       else
  1961.         nodeid++;
  1962.       structptr = structptr->next;
  1963.     }
  1964.     if (found)
  1965.     {
  1966.       nodept3 = ptk_point3(structptr->pos.x, structptr->pos.y, 0.0);
  1967.       nodept3 = ptk_transform3(topptr->globaltran, &nodept3);
  1968.       *nodept = ptk_point(nodept3.x, nodept3.y);
  1969.     }
  1970.     else
  1971.       *err = 2;
  1972.   }
  1973.   else
  1974.     *err = 1;
  1975. }  /* ptk_inqnodeposition */
  1976.  
  1977. /*--------------------------------------------------------------------------*/
  1978.  
  1979. /*function:external*/
  1980. extern void ptk_tidytopology(C(Pint) wsid, C(Pint) topid, 
  1981.             C(ptkenodetype) nodetype,
  1982.             C(Pint) pickdev, C(Pint) pickpet, C(Ppick_data *) pickdatarec,
  1983.             C(Pint) locdev, C(Pint) locpet, C(Ploc_data *) locdatarec)
  1984. PreANSI(Pint wsid)
  1985. PreANSI(Pint topid)
  1986. PreANSI(ptkenodetype nodetype)
  1987. PreANSI(Pint pickdev)
  1988. PreANSI(Pint pickpet)
  1989. PreANSI(Ppick_data *pickdatarec)
  1990. PreANSI(Pint locdev)
  1991. PreANSI(Pint locpet)
  1992. PreANSI(Ploc_data *locdatarec)
  1993. /*
  1994. ** \parambegin
  1995. ** \param{Pint}{wsid}{workstation identifier}{IN}
  1996. ** \param{Pint}{topid}{topology identifier}{IN}
  1997. ** \param{ptkenodetype}{nodetype}{type of node}{IN}
  1998. ** \param{Pint}{pickdev}{pick device}{IN}
  1999. ** \param{Pint}{pickpet}{pick prompt/echo type}{IN}
  2000. ** \param{Ppick\_data *}{pickdatarec}{pick data record}{IN}
  2001. ** \param{Pint}{locdev}{locator device}{IN}
  2002. ** \param{Pint}{locpet}{locator prompt/echo type}{IN}
  2003. ** \param{Ploc\_data *}{locdatarec}{locator data record}{IN}
  2004. ** \paramend
  2005. ** \blurb{This function enables the user to set the position of
  2006. ** a topology node, or group of nodes, interactively. The pick device
  2007. ** {\tt pickdev} is used to request a topology node and if
  2008. ** successful the locator device {\tt locdev} is used to specify
  2009. ** a new node position. Prompt and echo types may be set for both
  2010. ** the pick and locator devices.}
  2011. */
  2012. {
  2013.   Pint nodeid, inclnames, i, initview, viewindex;
  2014.   ptkboolean found;
  2015.   Ppick_path initpath, pick;
  2016.   Plimit3 echo;
  2017.   Ppick_path_elem pathel[10];
  2018.   Pfloat maxdevx, maxdevy, maxdevz;
  2019.   Pfilter pickfilt;
  2020.   Pin_status status;
  2021.   Ppoint initpos, locpos;
  2022.  
  2023.   settop(topid);
  2024.   if (topptr != NULL)
  2025.   {
  2026.     ptk_inqmaxdevicecoords3(wsid, &maxdevx, &maxdevy, &maxdevz);
  2027.     echo = ptk_limit3(0.0, maxdevx, 0.0, maxdevy, 0.0, maxdevz);
  2028.     /* pick topology node */
  2029.     pset_pick_mode(wsid, pickdev, POP_REQ, PSWITCH_ECHO);
  2030.     initpath.depth = 0;
  2031.     /* Implementation dependent code because of differences in
  2032.     ** valid initial status.
  2033.     */
  2034. #ifdef SUN
  2035.     pinit_pick3(wsid, pickdev, PIN_STATUS_NONE, &initpath, pickpet, &echo, 
  2036.                 pickdatarec, PORDER_TOP_FIRST);
  2037. #endif
  2038. #ifdef HP
  2039.     pinit_pick3(wsid, pickdev, PIN_STATUS_NO_IN, &initpath, pickpet, &echo, 
  2040.                 pickdatarec, PORDER_TOP_FIRST);
  2041. #endif
  2042.     pset_pick_mode(wsid, pickdev, POP_REQ, PSWITCH_ECHO);
  2043.     pickfilt.incl_set.num_ints = 1;
  2044.     pickfilt.incl_set.ints = &inclnames;
  2045.     inclnames = topptr->topologyname;
  2046.     pickfilt.excl_set.num_ints = 0;
  2047.     pset_pick_filter(wsid, pickdev, &pickfilt);
  2048.     pick.path_list = pathel;
  2049.     preq_pick(wsid, pickdev, 10, &status, &pick);
  2050.     if (status != PIN_STATUS_OK)
  2051.       return;
  2052.   
  2053.     /* find picked node */
  2054.     i = 0;
  2055.     found = FALSE;
  2056.     while ((!found) && (i < 10))
  2057.     {
  2058.       if (pick.path_list[i].struct_id == topptr->topologystid)
  2059.       {
  2060.         nodeid = pick.path_list[i].pick_id;
  2061.         found = TRUE;
  2062.       }
  2063.       i++;
  2064.     }
  2065.     /* locate point */
  2066.     pset_loc_mode(wsid, locdev, POP_REQ, PSWITCH_ECHO);
  2067.     initview = 0;
  2068.     initpos = ptk_point(0.5, 0.5);
  2069.     pinit_loc(wsid, locdev, initview, &initpos, locpet, &echo, locdatarec);
  2070.     pset_loc_mode(wsid, locdev, POP_REQ, PSWITCH_ECHO);
  2071.     preq_loc(wsid, locdev, &status, &viewindex, &locpos);
  2072.     
  2073.     if (status == PIN_STATUS_NONE)
  2074.       return;
  2075.   
  2076.     ptk_setnodeposition(topid, nodeid, &locpos, nodetype);
  2077.   }
  2078. }  /* ptk_tidytopology */
  2079.  
  2080. /*--------------------------------------------------------------------------*/
  2081.  
  2082. /*function:external*/
  2083. extern void ptk_posttopology(C(Pint) wsid, C(Pint) topid, C(Pfloat) priority)
  2084. PreANSI(Pint wsid)
  2085. PreANSI(Pint topid)
  2086. PreANSI(Pfloat priority)
  2087. /*
  2088. ** \parambegin
  2089. ** \param{Pint}{wsid}{workstation identifier}{IN}
  2090. ** \param{Pint}{topid}{topology identifier}{IN}
  2091. ** \param{Pfloat}{priority}{display priority}{IN}
  2092. ** \paramend
  2093. ** \blurb{This function posts a topology diagram structure to the
  2094. ** workstation {\tt wsid}.}
  2095. */
  2096. {
  2097.   settop(topid);
  2098.   if (topptr != NULL)
  2099.   {
  2100.     ptk_poststruct(wsid, topptr->topologystid, priority);
  2101.     addtointlst(wsid, &topptr->posted);
  2102.   }
  2103. }  /* ptk_posttopology */
  2104.  
  2105. /*--------------------------------------------------------------------------*/
  2106.  
  2107. /*function:external*/
  2108. extern void ptk_unposttopology(C(Pint) wsid, C(Pint) topid)
  2109. PreANSI(Pint wsid)
  2110. PreANSI(Pint topid)
  2111. /*
  2112. ** \parambegin
  2113. ** \param{Pint}{wsid}{workstation identifier}{IN}
  2114. ** \param{Pint}{topid}{topology identifier}{IN}
  2115. ** \paramend
  2116. ** \blurb{This function unposts the topology diagram structure from
  2117. ** the workstation {\tt wsid}.}
  2118. */
  2119. {
  2120.   settop(topid);
  2121.   if (topptr != NULL)
  2122.   {
  2123.     punpost_struct(wsid, topptr->topologystid);
  2124.     removefromintlst(wsid, &topptr->posted);
  2125.   }
  2126. }  /* ptk_unposttopology */
  2127.  
  2128. /*--------------------------------------------------------------------------*/
  2129.  
  2130. /*function:external*/
  2131. extern ptkboolean ptk_deltopology(C(Pint) topid)
  2132. PreANSI(Pint topid)
  2133. /*
  2134. ** \parambegin
  2135. ** \param{Pint}{topid}{topology identifier}{IN}
  2136. ** \paramend
  2137. ** \blurb{This function deletes a topology diagram from the PHIGS Toolkit
  2138. ** topology store. The function returns TRUE if a topology is deleted, 
  2139. ** otherwise FALSE.}
  2140. */
  2141. {
  2142.   ptkstopdraw *ptr, *junk;
  2143.   char stname[20];
  2144.  
  2145.   settop(topid);
  2146.   if (topptr != NULL)
  2147.   {
  2148.     if (topptr->topologytype == PTKESTRUCTTOPOLOGY)
  2149.       delstructnodes();
  2150.     ptr = firsttop;
  2151.     if (ptr->topologyid == topid)
  2152.     {
  2153.       firsttop = firsttop->next;
  2154.       if (lasttop->topologyid == topid)
  2155.         lasttop = firsttop;
  2156.     }
  2157.     else
  2158.     {
  2159.       while (ptr->next->topologyid != topid)
  2160.       {
  2161.         ptr = ptr->next;
  2162.         if (ptr->next == NULL)
  2163.           return FALSE;
  2164.       }
  2165.       junk = ptr->next;
  2166.       ptr->next = junk->next;
  2167.       if (ptr->next == NULL)
  2168.         lasttop = ptr;
  2169.     }
  2170.     pdel_struct(ptr->topologystid);
  2171.     /* dispose structlist */
  2172.     if (ptr->structlist != NULL)
  2173.       disposestructlist(ptr->structlist);
  2174.     /* dispose rowlist */
  2175.     if (ptr->rowlist != NULL)
  2176.       disposerowlist(ptr->rowlist);
  2177.     free(ptr);
  2178.  
  2179.     /* delete strings */
  2180.     sprintf(stname, "ptk$topology%d", topid);
  2181.     ptk_delstring("structureid", stname);
  2182.     sprintf(stname, "name$topology%d", topid);
  2183.     ptk_delstring("name", stname);
  2184.     topologycount--;
  2185.     return TRUE;
  2186.   }
  2187.   else
  2188.     return FALSE;
  2189. }  /* ptk_deltopology */
  2190.  
  2191. /*--------------------------------------------------------------------------*/
  2192.  
  2193. /*function:external*/
  2194. extern void ptk_storetopologylayout(C(FILE *) fileptr, C(Pint) topid)
  2195. PreANSI(FILE *fileptr)
  2196. PreANSI(Pint topid)
  2197. /*
  2198. ** \parambegin
  2199. ** \param{FILE *}{fileptr}{pointer to file}{OUT}
  2200. ** \param{Pint}{topid}{topology identifier}{IN}
  2201. ** \paramend
  2202. ** \blurb{This function saves a topology layout in a text file. The
  2203. ** layout refers to the positions of all the topology nodes. The
  2204. ** format of the stored layout is:
  2205. ** 
  2206. ** {\tt start}
  2207. ** {\tt (for each node in topology diagram)}
  2208. ** {\tt x y}
  2209. ** {\tt end}
  2210. ** }
  2211. */
  2212. {
  2213.   ptksstruct *structptr;
  2214.  
  2215.   settop(topid);
  2216.   if (topptr != NULL)
  2217.   {
  2218.     structptr = topptr->structlist;
  2219.     fprintf(fileptr, "\nstart\n");
  2220.     while (structptr != NULL)
  2221.     {
  2222.       fprintf(fileptr, "%f %f\n", structptr->pos.x, structptr->pos.y);
  2223.       structptr = structptr->next;
  2224.     }
  2225.     fprintf(fileptr, "end\n");
  2226.   }
  2227. }  /* ptk_storetopologylayout */
  2228.  
  2229. /*--------------------------------------------------------------------------*/
  2230.  
  2231. /*function:external*/
  2232. extern void ptk_restoretopologylayout(C(FILE *) fileptr, C(Pint) topid)
  2233. PreANSI(FILE *fileptr)
  2234. PreANSI(Pint topid)
  2235. /*
  2236. ** \parambegin
  2237. ** \param{FILE *}{fileptr}{pointer to file}{OUT}
  2238. ** \param{Pint}{topid}{topology identifier}{IN}
  2239. ** \paramend
  2240. ** \blurb{This function reads a topology layout from a text file.
  2241. ** The layout is used to reposition the nodes of the topology
  2242. ** diagram {\tt topid} but will only really make sense if the layout
  2243. ** was stored originally from the same topology.} 
  2244. */
  2245. {
  2246.   ptksstruct *structptr;
  2247.   char str[255];
  2248.   Pint_list nameset;
  2249.   Pint k;
  2250.  
  2251.   settop(topid);
  2252.   if (topptr != NULL)
  2253.   {
  2254.     structptr = topptr->structlist;
  2255.     /* find `start' */
  2256.     do
  2257.     {
  2258.       fgets(str, 255, fileptr);    
  2259.     } while (strncmp(str, "start", 5) != 0);
  2260.     fgets(str, 255, fileptr);    
  2261.     while ((structptr != NULL) && (strncmp(str, "end", 3) != 0)) 
  2262.     {
  2263.       sscanf(str, "%f %f\n", &structptr->pos.x, &structptr->pos.y);
  2264.       structptr = structptr->next;
  2265.       fgets(str, 255, fileptr);    
  2266.     }
  2267.  
  2268.     /* remove keys */
  2269.     topptr->keyno = 0;
  2270.     for (k = 0; k <= 254; k++)
  2271.       topptr->rowmaxx[k] = -32768.0;
  2272.  
  2273.     ptk_openstruct(topptr->topologystid);
  2274.     pset_elem_ptr(0);
  2275.     pdel_elems_labels(ptk_stringtoint("label", "globaltran"), 
  2276.                    ptk_stringtoint("label", "highlightattrs"));
  2277.     pdel_elems_labels(ptk_stringtoint("label", "highlightnode"), 
  2278.                    ptk_stringtoint("label", "attrs"));
  2279.     pdel_elems_labels(ptk_stringtoint("label", "starttopology"), 
  2280.                    ptk_stringtoint("label", "endtopology"));
  2281.     topptr->extent = ptk_limit3(1000000.0, -10000000.0, 10000000.0,
  2282.                                  -10000000.0, 0.0, 1.0);
  2283.     pset_edit_mode(PEDIT_INSERT);  
  2284.     setnode(1.0, 1.0);
  2285.     switch (topptr->topologytype)
  2286.     {
  2287.       case PTKEBOXTOPOLOGY: 
  2288.         drawnodes();
  2289.         break;
  2290.   
  2291.       case PTKESTRUCTNETTOPOLOGY:
  2292.         drawstructnetnodes();
  2293.         break;
  2294.   
  2295.       case PTKESTRUCTTOPOLOGY:
  2296.         drawstructnodes();
  2297.         break;
  2298.     }
  2299.     nameset.num_ints = 1;
  2300.     nameset.ints = &topptr->topologyname;
  2301.     premove_names_set(&nameset);  
  2302.     drawconnections();
  2303.     drawnames();
  2304.     drawkeys();
  2305.     setscaling();
  2306.     ptk_closestruct();
  2307.   }
  2308. }  /* ptk_restoretopologylayout */
  2309.  
  2310. /*--------------------------------------------------------------------------*/
  2311.  
  2312. /*function:external*/
  2313. extern void ptk_inqpostedtopologies(C(Pint) wsid, C(Pint) size, 
  2314.             C(Pint_list *) topids, C(Pint *) totalsize, C(Pint *) err)
  2315. PreANSI(Pint wsid)
  2316. PreANSI(Pint size)
  2317. PreANSI(Pint_list *topids)
  2318. PreANSI(Pint *totalsize)
  2319. PreANSI(Pint *err)
  2320. /*
  2321. ** \parambegin
  2322. ** \param{Pint}{wsid}{workstation identifier}{IN}
  2323. ** \param{Pint}{size}{size of buffer}{IN}
  2324. ** \param{Pint\_list *}{topids}{list of posted topologies}{OUT}
  2325. ** \param{Pint *}{totalsize}{length of posted topologies list}{OUT}
  2326. ** \param{Pint *}{err}{error indicator}{OUT}
  2327. ** \paramend
  2328. ** \blurb{This function may be used to obtain a list of all the
  2329. ** topology diagrams which are posted to the workstation {\tt wsid}.}
  2330. */
  2331. {
  2332.   ptkstopdraw *ptrtop;
  2333.  
  2334.   *err = 0;
  2335.   *totalsize = 0;
  2336.   ptrtop = firsttop;
  2337.   while (ptrtop != NULL)
  2338.   {
  2339.     if ((inintlst(wsid, &ptrtop->posted) != -1))
  2340.       (*totalsize)++;
  2341.     ptrtop = ptrtop->next;
  2342.   }
  2343.   if (size >= *totalsize)
  2344.   {
  2345.     topids->num_ints = 0;
  2346.     ptrtop = firsttop;
  2347.     while (ptrtop != NULL)
  2348.     {
  2349.       if ((inintlst(wsid, &ptrtop->posted) != -1))
  2350.       {
  2351.         topids->ints[topids->num_ints] = ptrtop->topologyid;
  2352.         topids->num_ints++;
  2353.       }
  2354.       ptrtop = ptrtop->next;
  2355.     }
  2356.   }
  2357. }  /* ptk_inqpostedtopologies */
  2358.  
  2359. /*--------------------------------------------------------------------------*/
  2360.  
  2361. /*function:external*/
  2362. extern void ptk_inqtopologyids(C(Pint) size, C(Pint_list *) topids, 
  2363.                                C(Pint *) totalsize, C(Pint *) err)
  2364. PreANSI(Pint size)
  2365. PreANSI(Pint_list *topids)
  2366. PreANSI(Pint *totalsize)
  2367. PreANSI(Pint *err)
  2368. /*
  2369. ** \parambegin
  2370. ** \param{Pint}{size}{size of buffer}{IN}
  2371. ** \param{Pint\_list *}{topids}{list of topology identifiers}{OUT}
  2372. ** \param{Pint *}{totalsize}{length of topology identifiers list}{OUT}
  2373. ** \param{Pint *}{err}{error indicator}{OUT}
  2374. ** \paramend
  2375. ** \blurb{This function may be used to obtain a list of all the topology
  2376. ** diagrams in the PHIGS Toolkit topology store.}
  2377. */
  2378. {
  2379.   ptkstopdraw *ptrtop;
  2380.  
  2381.   *err = 0;
  2382.   *totalsize = topologycount;
  2383.   if (size >= *totalsize)
  2384.   {
  2385.     topids->num_ints = 0;
  2386.     ptrtop = firsttop;
  2387.     while (ptrtop != NULL)
  2388.     {
  2389.       topids->ints[topids->num_ints] = ptrtop->topologyid;
  2390.       topids->num_ints++;
  2391.       ptrtop = ptrtop->next;
  2392.     }
  2393.   }
  2394. }  /* ptk_inqtopologyids */
  2395.  
  2396. /*--------------------------------------------------------------------------*/
  2397.  
  2398. /*function:external*/
  2399. extern void ptk_inqtopologystructid(C(Pint) topid, C(Pint *) topstid,
  2400.                                     C(Pint *) err)
  2401. PreANSI(Pint topid)
  2402. PreANSI(Pint *topstid)
  2403. PreANSI(Pint *err)
  2404. /*
  2405. ** \parambegin
  2406. ** \param{Pint}{topid}{topology identifier}{IN}
  2407. ** \param{Pint *}{topstid}{topology structure identifier}{IN}
  2408. ** \param{Pint *}{err}{error indicator}{OUT}
  2409. ** \paramend
  2410. ** \blurb{This function may be used to obtain the structure identifier 
  2411. ** of the topology diagram {\tt topid}. In the case of the BOX topology
  2412. ** type the diagram is a single PHIGS structure but for STRUCT and
  2413. ** STRUCTNET type diagrams it is a structure network. 
  2414. ** The error code = 1 if {\tt topid} doesn't exist.}
  2415. */
  2416. {
  2417.   *err = 0;
  2418.   settop(topid);
  2419.   if (topptr != NULL)
  2420.     *topstid = topptr->topologystid;
  2421.   else
  2422.     *err = 1;
  2423. }  /* ptk_inqtopologystructid */
  2424.  
  2425. /*--------------------------------------------------------------------------*/
  2426.  
  2427. /*function:external*/
  2428. extern void ptk_inqtopologyname(C(Pint) topid, C(Pint *) name, C(Pint *) err) 
  2429. PreANSI(Pint topid)
  2430. PreANSI(Pint *name)
  2431. PreANSI(Pint *err)
  2432. /*
  2433. ** \parambegin
  2434. ** \param{Pint}{topid}{topology identifier}{IN}
  2435. ** \param{Pint *}{name}{topology name for nameset filters}{OUT}
  2436. ** \param{Pint *}{err}{error indicator}{OUT}
  2437. ** \paramend
  2438. ** \blurb{This function may be used to obtain the topology name for use 
  2439. ** in the pick filter. When a topology name is added to the pick filter
  2440. ** only the topology nodes are pickable.
  2441. ** The error code = 1 if {\tt topid} doesn't exist.}
  2442. */
  2443. {
  2444.   *err = 0;
  2445.   settop(topid);
  2446.   if (topptr != NULL)
  2447.   {
  2448.     *name = topptr->topologyname;
  2449.   }
  2450.   else
  2451.     *err = 1;
  2452. }  /* ptk_inqtopologyname */
  2453.  
  2454. /*--------------------------------------------------------------------------*/
  2455.  
  2456. /*function:external*/
  2457. extern void ptk_settopologyhighlightnode(C(Pint) topid, C(Pint) topnodestid)
  2458. PreANSI(Pint topid)
  2459. PreANSI(Pint topnodestid)
  2460. /*
  2461. ** \parambegin
  2462. ** \param{Pint}{topid}{topology identifier}{IN}
  2463. ** \param{Pint}{topnodestid}{topology node structure identifier}{IN}
  2464. ** \paramend
  2465. ** \blurb{This function highlights a single topology node by
  2466. ** setting the colour attribute values of the edge and interior of
  2467. ** the node box. This function only works for BOX topology types.}
  2468. */
  2469. {
  2470.   Pint nodeid;
  2471.   ptksstruct *structptr;
  2472.   ptkboolean found;
  2473.  
  2474.   found = FALSE;
  2475.   nodeid = 0;
  2476.   settop(topid);
  2477.   if (topptr != NULL)
  2478.   {
  2479.     structptr = topptr->structlist;
  2480.     while ((structptr != NULL) && (!found))
  2481.     {
  2482.       if (structptr->name == topnodestid)
  2483.         found = TRUE;
  2484.       else
  2485.         nodeid++;
  2486.       structptr = structptr->next;
  2487.     }
  2488.     if (found)
  2489.     {
  2490.       topptr->highlightnode = nodeid;
  2491.       redrawtopology();
  2492.     }
  2493.   }
  2494. }  /* ptk_settopologyhighlightnode */
  2495.  
  2496. /*--------------------------------------------------------------------------*/
  2497.  
  2498. /*function:external*/
  2499. extern void ptk_inqtopologyhighlightnode(C(Pint) topid, 
  2500.                               C(Pint *) topnodestid, C(Pint *) err)
  2501. PreANSI(Pint topid)
  2502. PreANSI(Pint *topnodestid)
  2503. PreANSI(Pint *err)
  2504. /*
  2505. ** \parambegin
  2506. ** \param{Pint}{topid}{topology identifier}{IN}
  2507. ** \param{Pint *}{topnodestid}{topology node structure identifier}{OUT}
  2508. ** \param{Pint *}{err}{error indicator}{OUT}
  2509. ** \paramend
  2510. ** \blurb{This function may be used to obtain the structure
  2511. ** identifier of the currently highlighted topology node. The error code
  2512. ** = 1 if {\tt topid} doesn't exist and = 2 if there is no
  2513. ** highlighted node.}
  2514. */
  2515. {
  2516.   Pint i;
  2517.   ptksstruct *structptr;
  2518.  
  2519.   *err = 0;
  2520.   settop(topid);
  2521.   if (topptr != NULL)
  2522.   {
  2523.     if (topptr->highlightnode != -1)
  2524.     {
  2525.       structptr = topptr->structlist;
  2526.       for (i = 0; i < topptr->highlightnode; i++)
  2527.         structptr = structptr->next;    
  2528.       *topnodestid = structptr->name;
  2529.     }
  2530.     else
  2531.       *err = 2;
  2532.   }
  2533.   else
  2534.     *err = 1;
  2535. }  /* ptk_inqtopologyhighlightnode */
  2536.  
  2537. /*--------------------------------------------------------------------------*/
  2538.  
  2539. /* end of topo.c */
  2540.  
  2541.